| # Copyright 2016 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 or at |
| # https://developers.google.com/open-source/licenses/bsd |
| |
| """Unit tests for features_svc module.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| import logging |
| import mox |
| import time |
| import unittest |
| import mock |
| |
| from google.appengine.api import memcache |
| from google.appengine.ext import testbed |
| |
| import settings |
| |
| from features import filterrules_helpers |
| from features import features_constants |
| from framework import exceptions |
| from framework import framework_constants |
| from framework import sql |
| from proto import tracker_pb2 |
| from proto import features_pb2 |
| from services import chart_svc |
| from services import features_svc |
| from services import star_svc |
| from services import user_svc |
| from testing import fake |
| from tracker import tracker_bizobj |
| from tracker import tracker_constants |
| |
| |
| # NOTE: we are in the process of moving away from mox towards mock. |
| # This file is a mix of both. All new tests or big test updates should make |
| # use of the mock package. |
| def MakeFeaturesService(cache_manager, my_mox): |
| features_service = features_svc.FeaturesService(cache_manager, |
| fake.ConfigService()) |
| features_service.hotlist_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| features_service.hotlist2issue_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| features_service.hotlist2user_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| return features_service |
| |
| |
| class HotlistTwoLevelCacheTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.testbed = testbed.Testbed() |
| self.testbed.activate() |
| self.testbed.init_memcache_stub() |
| |
| self.mox = mox.Mox() |
| self.cnxn = self.mox.CreateMock(sql.MonorailConnection) |
| self.cache_manager = fake.CacheManager() |
| self.features_service = MakeFeaturesService(self.cache_manager, self.mox) |
| |
| def tearDown(self): |
| self.testbed.deactivate() |
| |
| def testDeserializeHotlists(self): |
| hotlist_rows = [ |
| (123, 'hot1', 'test hot 1', 'test hotlist', False, ''), |
| (234, 'hot2', 'test hot 2', 'test hotlist', False, '')] |
| |
| ts = 20021111111111 |
| issue_rows = [ |
| (123, 567, 10, 111, ts, ''), (123, 678, 9, 111, ts, ''), |
| (234, 567, 0, 111, ts, '')] |
| role_rows = [ |
| (123, 111, 'owner'), (123, 444, 'owner'), |
| (123, 222, 'editor'), |
| (123, 333, 'follower'), |
| (234, 111, 'owner')] |
| hotlist_dict = self.features_service.hotlist_2lc._DeserializeHotlists( |
| hotlist_rows, issue_rows, role_rows) |
| |
| self.assertItemsEqual([123, 234], list(hotlist_dict.keys())) |
| self.assertEqual(123, hotlist_dict[123].hotlist_id) |
| self.assertEqual('hot1', hotlist_dict[123].name) |
| self.assertItemsEqual([111, 444], hotlist_dict[123].owner_ids) |
| self.assertItemsEqual([222], hotlist_dict[123].editor_ids) |
| self.assertItemsEqual([333], hotlist_dict[123].follower_ids) |
| self.assertEqual(234, hotlist_dict[234].hotlist_id) |
| self.assertItemsEqual([111], hotlist_dict[234].owner_ids) |
| |
| |
| class HotlistIDTwoLevelCache(unittest.TestCase): |
| |
| def setUp(self): |
| self.testbed = testbed.Testbed() |
| self.testbed.activate() |
| self.testbed.init_memcache_stub() |
| |
| self.mox = mox.Mox() |
| self.cnxn = self.mox.CreateMock(sql.MonorailConnection) |
| self.cache_manager = fake.CacheManager() |
| self.features_service = MakeFeaturesService(self.cache_manager, self.mox) |
| self.hotlist_id_2lc = self.features_service.hotlist_id_2lc |
| |
| def tearDown(self): |
| memcache.flush_all() |
| self.testbed.deactivate() |
| self.mox.UnsetStubs() |
| self.mox.ResetAll() |
| |
| def testGetAll(self): |
| cached_keys = [('name1', 111), ('name2', 222)] |
| self.hotlist_id_2lc.CacheItem(cached_keys[0], 121) |
| self.hotlist_id_2lc.CacheItem(cached_keys[1], 122) |
| |
| # Set up DB query mocks. |
| # Test that a ('name1', 222) or ('name3', 333) hotlist |
| # does not get returned by GetAll even though these hotlists |
| # exist and are returned by the DB queries. |
| from_db_keys = [ |
| ('name1', 333), ('name3', 222), ('name3', 555)] |
| self.features_service.hotlist2user_tbl.Select = mock.Mock(return_value=[ |
| (123, 333), # name1 hotlist |
| (124, 222), # name3 hotlist |
| (125, 222), # name1 hotlist, should be ignored |
| (126, 333), # name3 hotlist, should be ignored |
| (127, 555), # wrongname hotlist, should be ignored |
| ]) |
| self.features_service.hotlist_tbl.Select = mock.Mock( |
| return_value=[(123, 'Name1'), (124, 'Name3'), |
| (125, 'Name1'), (126, 'Name3')]) |
| |
| hit, misses = self.hotlist_id_2lc.GetAll( |
| self.cnxn, cached_keys + from_db_keys) |
| |
| # Assertions |
| self.features_service.hotlist2user_tbl.Select.assert_called_once_with( |
| self.cnxn, cols=['hotlist_id', 'user_id'], user_id=[555, 333, 222], |
| role_name='owner') |
| hotlist_ids = [123, 124, 125, 126, 127] |
| self.features_service.hotlist_tbl.Select.assert_called_once_with( |
| self.cnxn, cols=['id', 'name'], id=hotlist_ids, is_deleted=False, |
| where=[('LOWER(name) IN (%s,%s)', ['name3', 'name1'])]) |
| |
| self.assertEqual(hit,{ |
| ('name1', 111): 121, |
| ('name2', 222): 122, |
| ('name1', 333): 123, |
| ('name3', 222): 124}) |
| self.assertEqual(from_db_keys[-1:], misses) |
| |
| |
| class FeaturesServiceTest(unittest.TestCase): |
| |
| def MakeMockTable(self): |
| return self.mox.CreateMock(sql.SQLTableManager) |
| |
| def setUp(self): |
| self.testbed = testbed.Testbed() |
| self.testbed.activate() |
| self.testbed.init_memcache_stub() |
| |
| self.mox = mox.Mox() |
| self.cnxn = self.mox.CreateMock(sql.MonorailConnection) |
| self.cache_manager = fake.CacheManager() |
| self.config_service = fake.ConfigService() |
| |
| self.features_service = features_svc.FeaturesService(self.cache_manager, |
| self.config_service) |
| self.issue_service = fake.IssueService() |
| self.chart_service = self.mox.CreateMock(chart_svc.ChartService) |
| |
| for table_var in [ |
| 'user2savedquery_tbl', 'quickedithistory_tbl', |
| 'quickeditmostrecent_tbl', 'savedquery_tbl', |
| 'savedqueryexecutesinproject_tbl', 'project2savedquery_tbl', |
| 'filterrule_tbl', 'hotlist_tbl', 'hotlist2issue_tbl', |
| 'hotlist2user_tbl']: |
| setattr(self.features_service, table_var, self.MakeMockTable()) |
| |
| def tearDown(self): |
| memcache.flush_all() |
| self.testbed.deactivate() |
| self.mox.UnsetStubs() |
| self.mox.ResetAll() |
| |
| ### quickedit command history |
| |
| def testGetRecentCommands(self): |
| self.features_service.quickedithistory_tbl.Select( |
| self.cnxn, cols=['slot_num', 'command', 'comment'], |
| user_id=1, project_id=12345).AndReturn( |
| [(1, 'status=New', 'Brand new issue')]) |
| self.features_service.quickeditmostrecent_tbl.SelectValue( |
| self.cnxn, 'slot_num', default=1, user_id=1, project_id=12345 |
| ).AndReturn(1) |
| self.mox.ReplayAll() |
| slots, recent_slot_num = self.features_service.GetRecentCommands( |
| self.cnxn, 1, 12345) |
| self.mox.VerifyAll() |
| |
| self.assertEqual(1, recent_slot_num) |
| self.assertEqual( |
| len(tracker_constants.DEFAULT_RECENT_COMMANDS), len(slots)) |
| self.assertEqual('status=New', slots[0][1]) |
| |
| def testStoreRecentCommand(self): |
| self.features_service.quickedithistory_tbl.InsertRow( |
| self.cnxn, replace=True, user_id=1, project_id=12345, |
| slot_num=1, command='status=New', comment='Brand new issue') |
| self.features_service.quickeditmostrecent_tbl.InsertRow( |
| self.cnxn, replace=True, user_id=1, project_id=12345, |
| slot_num=1) |
| self.mox.ReplayAll() |
| self.features_service.StoreRecentCommand( |
| self.cnxn, 1, 12345, 1, 'status=New', 'Brand new issue') |
| self.mox.VerifyAll() |
| |
| def testExpungeQuickEditHistory(self): |
| self.features_service.quickeditmostrecent_tbl.Delete( |
| self.cnxn, project_id=12345) |
| self.features_service.quickedithistory_tbl.Delete( |
| self.cnxn, project_id=12345) |
| self.mox.ReplayAll() |
| self.features_service.ExpungeQuickEditHistory( |
| self.cnxn, 12345) |
| self.mox.VerifyAll() |
| |
| def testExpungeQuickEditsByUsers(self): |
| user_ids = [333, 555, 777] |
| commit = False |
| |
| self.features_service.quickeditmostrecent_tbl.Delete = mock.Mock() |
| self.features_service.quickedithistory_tbl.Delete = mock.Mock() |
| |
| self.features_service.ExpungeQuickEditsByUsers( |
| self.cnxn, user_ids, limit=50) |
| |
| self.features_service.quickeditmostrecent_tbl.Delete.\ |
| assert_called_once_with(self.cnxn, user_id=user_ids, commit=commit, limit=50) |
| self.features_service.quickedithistory_tbl.Delete.\ |
| assert_called_once_with(self.cnxn, user_id=user_ids, commit=commit, limit=50) |
| |
| ### Saved User and Project Queries |
| |
| def testGetSavedQuery_Valid(self): |
| self.features_service.savedquery_tbl.Select( |
| self.cnxn, cols=features_svc.SAVEDQUERY_COLS, id=[1]).AndReturn( |
| [(1, 'query1', 100, 'owner:me')]) |
| self.features_service.savedqueryexecutesinproject_tbl.Select( |
| self.cnxn, cols=features_svc.SAVEDQUERYEXECUTESINPROJECT_COLS, |
| query_id=[1]).AndReturn([(1, 12345)]) |
| self.mox.ReplayAll() |
| saved_query = self.features_service.GetSavedQuery( |
| self.cnxn, 1) |
| self.mox.VerifyAll() |
| self.assertEqual(1, saved_query.query_id) |
| self.assertEqual('query1', saved_query.name) |
| self.assertEqual(100, saved_query.base_query_id) |
| self.assertEqual('owner:me', saved_query.query) |
| self.assertEqual([12345], saved_query.executes_in_project_ids) |
| |
| def testGetSavedQuery_Invalid(self): |
| self.features_service.savedquery_tbl.Select( |
| self.cnxn, cols=features_svc.SAVEDQUERY_COLS, id=[99]).AndReturn([]) |
| self.features_service.savedqueryexecutesinproject_tbl.Select( |
| self.cnxn, cols=features_svc.SAVEDQUERYEXECUTESINPROJECT_COLS, |
| query_id=[99]).AndReturn([]) |
| self.mox.ReplayAll() |
| saved_query = self.features_service.GetSavedQuery( |
| self.cnxn, 99) |
| self.mox.VerifyAll() |
| self.assertIsNone(saved_query) |
| |
| def SetUpUsersSavedQueries(self, has_query_id=True): |
| query = tracker_bizobj.MakeSavedQuery(1, 'query1', 100, 'owner:me') |
| self.features_service.saved_query_cache.CacheItem(1, [query]) |
| |
| if has_query_id: |
| self.features_service.user2savedquery_tbl.Select( |
| self.cnxn, |
| cols=features_svc.SAVEDQUERY_COLS + ['user_id', 'subscription_mode'], |
| left_joins=[('SavedQuery ON query_id = id', [])], |
| order_by=[('rank', [])], |
| user_id=[2]).AndReturn( |
| [(2, 'query2', 100, 'status:New', 2, 'Sub_Mode')]) |
| self.features_service.savedqueryexecutesinproject_tbl.Select( |
| self.cnxn, |
| cols=features_svc.SAVEDQUERYEXECUTESINPROJECT_COLS, |
| query_id=set([2])).AndReturn([(2, 12345)]) |
| else: |
| self.features_service.user2savedquery_tbl.Select( |
| self.cnxn, |
| cols=features_svc.SAVEDQUERY_COLS + ['user_id', 'subscription_mode'], |
| left_joins=[('SavedQuery ON query_id = id', [])], |
| order_by=[('rank', [])], |
| user_id=[2]).AndReturn([]) |
| |
| def testGetUsersSavedQueriesDict(self): |
| self.SetUpUsersSavedQueries() |
| self.mox.ReplayAll() |
| results_dict = self.features_service._GetUsersSavedQueriesDict( |
| self.cnxn, [1, 2]) |
| self.mox.VerifyAll() |
| self.assertIn(1, results_dict) |
| self.assertIn(2, results_dict) |
| |
| def testGetUsersSavedQueriesDictWithoutSavedQueries(self): |
| self.SetUpUsersSavedQueries(False) |
| self.mox.ReplayAll() |
| results_dict = self.features_service._GetUsersSavedQueriesDict( |
| self.cnxn, [1, 2]) |
| self.mox.VerifyAll() |
| self.assertIn(1, results_dict) |
| self.assertNotIn(2, results_dict) |
| |
| def testGetSavedQueriesByUserID(self): |
| self.SetUpUsersSavedQueries() |
| self.mox.ReplayAll() |
| saved_queries = self.features_service.GetSavedQueriesByUserID( |
| self.cnxn, 2) |
| self.mox.VerifyAll() |
| self.assertEqual(1, len(saved_queries)) |
| self.assertEqual(2, saved_queries[0].query_id) |
| |
| def SetUpCannedQueriesForProjects(self, project_ids): |
| query = tracker_bizobj.MakeSavedQuery( |
| 2, 'project-query-2', 110, 'owner:goose@chaos.honk') |
| self.features_service.canned_query_cache.CacheItem(12346, [query]) |
| self.features_service.canned_query_cache.CacheAll = mock.Mock() |
| self.features_service.project2savedquery_tbl.Select( |
| self.cnxn, cols=['project_id'] + features_svc.SAVEDQUERY_COLS, |
| left_joins=[('SavedQuery ON query_id = id', [])], |
| order_by=[('rank', [])], project_id=project_ids).AndReturn( |
| [(12345, 1, 'query1', 100, 'owner:me')]) |
| |
| def testGetCannedQueriesForProjects(self): |
| project_ids = [12345, 12346] |
| self.SetUpCannedQueriesForProjects(project_ids) |
| self.mox.ReplayAll() |
| results_dict = self.features_service.GetCannedQueriesForProjects( |
| self.cnxn, project_ids) |
| self.mox.VerifyAll() |
| self.assertIn(12345, results_dict) |
| self.assertIn(12346, results_dict) |
| self.features_service.canned_query_cache.CacheAll.assert_called_once_with( |
| results_dict) |
| |
| def testGetCannedQueriesByProjectID(self): |
| project_id= 12345 |
| self.SetUpCannedQueriesForProjects([project_id]) |
| self.mox.ReplayAll() |
| result = self.features_service.GetCannedQueriesByProjectID( |
| self.cnxn, project_id) |
| self.mox.VerifyAll() |
| self.assertEqual(1, len(result)) |
| self.assertEqual(1, result[0].query_id) |
| |
| def SetUpUpdateSavedQueries(self, commit=True): |
| query1 = tracker_bizobj.MakeSavedQuery(1, 'query1', 100, 'owner:me') |
| query2 = tracker_bizobj.MakeSavedQuery(None, 'query2', 100, 'status:New') |
| saved_queries = [query1, query2] |
| savedquery_rows = [ |
| (sq.query_id or None, sq.name, sq.base_query_id, sq.query) |
| for sq in saved_queries] |
| self.features_service.savedquery_tbl.Delete( |
| self.cnxn, id=[1], commit=commit) |
| self.features_service.savedquery_tbl.InsertRows( |
| self.cnxn, features_svc.SAVEDQUERY_COLS, savedquery_rows, commit=commit, |
| return_generated_ids=True).AndReturn([11, 12]) |
| return saved_queries |
| |
| def testUpdateSavedQueries(self): |
| saved_queries = self.SetUpUpdateSavedQueries() |
| self.mox.ReplayAll() |
| self.features_service._UpdateSavedQueries( |
| self.cnxn, saved_queries, True) |
| self.mox.VerifyAll() |
| |
| def testUpdateCannedQueries(self): |
| self.features_service.project2savedquery_tbl.Delete( |
| self.cnxn, project_id=12345, commit=False) |
| canned_queries = self.SetUpUpdateSavedQueries(False) |
| project2savedquery_rows = [(12345, 0, 1), (12345, 1, 12)] |
| self.features_service.project2savedquery_tbl.InsertRows( |
| self.cnxn, features_svc.PROJECT2SAVEDQUERY_COLS, |
| project2savedquery_rows, commit=False) |
| self.features_service.canned_query_cache.Invalidate = mock.Mock() |
| self.cnxn.Commit() |
| self.mox.ReplayAll() |
| self.features_service.UpdateCannedQueries( |
| self.cnxn, 12345, canned_queries) |
| self.mox.VerifyAll() |
| self.features_service.canned_query_cache.Invalidate.assert_called_once_with( |
| self.cnxn, 12345) |
| |
| def testUpdateUserSavedQueries(self): |
| saved_queries = self.SetUpUpdateSavedQueries(False) |
| self.features_service.savedqueryexecutesinproject_tbl.Delete( |
| self.cnxn, query_id=[1], commit=False) |
| self.features_service.user2savedquery_tbl.Delete( |
| self.cnxn, user_id=1, commit=False) |
| user2savedquery_rows = [ |
| (1, 0, 1, 'noemail'), (1, 1, 12, 'noemail')] |
| self.features_service.user2savedquery_tbl.InsertRows( |
| self.cnxn, features_svc.USER2SAVEDQUERY_COLS, |
| user2savedquery_rows, commit=False) |
| self.features_service.savedqueryexecutesinproject_tbl.InsertRows( |
| self.cnxn, features_svc.SAVEDQUERYEXECUTESINPROJECT_COLS, [], |
| commit=False) |
| self.cnxn.Commit() |
| self.mox.ReplayAll() |
| self.features_service.UpdateUserSavedQueries( |
| self.cnxn, 1, saved_queries) |
| self.mox.VerifyAll() |
| |
| ### Subscriptions |
| |
| def testGetSubscriptionsInProjects(self): |
| sqeip_join_str = ( |
| 'SavedQueryExecutesInProject ON ' |
| 'SavedQueryExecutesInProject.query_id = User2SavedQuery.query_id') |
| user_join_str = ( |
| 'User ON ' |
| 'User.user_id = User2SavedQuery.user_id') |
| now = 1519418530 |
| self.mox.StubOutWithMock(time, 'time') |
| time.time().MultipleTimes().AndReturn(now) |
| absence_threshold = now - settings.subscription_timeout_secs |
| where = [ |
| ('(User.banned IS NULL OR User.banned = %s)', ['']), |
| ('User.last_visit_timestamp >= %s', [absence_threshold]), |
| ('(User.email_bounce_timestamp IS NULL OR ' |
| 'User.email_bounce_timestamp = %s)', [0]), |
| ] |
| self.features_service.user2savedquery_tbl.Select( |
| self.cnxn, cols=['User2SavedQuery.user_id'], distinct=True, |
| joins=[(sqeip_join_str, []), (user_join_str, [])], |
| subscription_mode='immediate', project_id=12345, |
| where=where).AndReturn( |
| [(1, 'asd'), (2, 'efg')]) |
| self.SetUpUsersSavedQueries() |
| self.mox.ReplayAll() |
| result = self.features_service.GetSubscriptionsInProjects( |
| self.cnxn, 12345) |
| self.mox.VerifyAll() |
| self.assertIn(1, result) |
| self.assertIn(2, result) |
| |
| def testExpungeSavedQueriesExecuteInProject(self): |
| self.features_service.savedqueryexecutesinproject_tbl.Delete( |
| self.cnxn, project_id=12345) |
| self.features_service.project2savedquery_tbl.Select( |
| self.cnxn, cols=['query_id'], project_id=12345).AndReturn( |
| [(1, 'asd'), (2, 'efg')]) |
| self.features_service.project2savedquery_tbl.Delete( |
| self.cnxn, project_id=12345) |
| self.features_service.savedquery_tbl.Delete( |
| self.cnxn, id=[1, 2]) |
| self.mox.ReplayAll() |
| self.features_service.ExpungeSavedQueriesExecuteInProject( |
| self.cnxn, 12345) |
| self.mox.VerifyAll() |
| |
| def testExpungeSavedQueriesByUsers(self): |
| user_ids = [222, 444, 666] |
| commit = False |
| |
| sv_rows = [(8,), (9,)] |
| self.features_service.user2savedquery_tbl.Select = mock.Mock( |
| return_value=sv_rows) |
| self.features_service.user2savedquery_tbl.Delete = mock.Mock() |
| self.features_service.savedqueryexecutesinproject_tbl.Delete = mock.Mock() |
| self.features_service.savedquery_tbl.Delete = mock.Mock() |
| |
| self.features_service.ExpungeSavedQueriesByUsers( |
| self.cnxn, user_ids, limit=50) |
| |
| self.features_service.user2savedquery_tbl.Select.assert_called_once_with( |
| self.cnxn, cols=['query_id'], user_id=user_ids, limit=50) |
| self.features_service.user2savedquery_tbl.Delete.assert_called_once_with( |
| self.cnxn, query_id=[8, 9], commit=commit) |
| self.features_service.savedqueryexecutesinproject_tbl.\ |
| Delete.assert_called_once_with( |
| self.cnxn, query_id=[8, 9], commit=commit) |
| self.features_service.savedquery_tbl.Delete.assert_called_once_with( |
| self.cnxn, id=[8, 9], commit=commit) |
| |
| |
| ### Filter Rules |
| |
| def testDeserializeFilterRules(self): |
| filterrule_rows = [ |
| (12345, 0, 'predicate1', 'default_status:New'), |
| (12345, 1, 'predicate2', 'default_owner_id:1 add_cc_id:2'), |
| ] |
| result_dict = self.features_service._DeserializeFilterRules( |
| filterrule_rows) |
| self.assertIn(12345, result_dict) |
| self.assertEqual(2, len(result_dict[12345])) |
| self.assertEqual('New', result_dict[12345][0].default_status) |
| self.assertEqual(1, result_dict[12345][1].default_owner_id) |
| self.assertEqual([2], result_dict[12345][1].add_cc_ids) |
| |
| def testDeserializeRuleConsequence_Multiple(self): |
| consequence = ('default_status:New default_owner_id:1 add_cc_id:2' |
| ' add_label:label-1 add_label:label.2' |
| ' add_notify:admin@example.com') |
| (default_status, default_owner_id, add_cc_ids, add_labels, |
| add_notify, warning, error |
| ) = self.features_service._DeserializeRuleConsequence( |
| consequence) |
| self.assertEqual('New', default_status) |
| self.assertEqual(1, default_owner_id) |
| self.assertEqual([2], add_cc_ids) |
| self.assertEqual(['label-1', 'label.2'], add_labels) |
| self.assertEqual(['admin@example.com'], add_notify) |
| self.assertEqual(None, warning) |
| self.assertEqual(None, error) |
| |
| def testDeserializeRuleConsequence_Warning(self): |
| consequence = ('warning:Do not use status:New if there is an owner') |
| (_status, _owner_id, _cc_ids, _labels, _notify, |
| warning, _error) = self.features_service._DeserializeRuleConsequence( |
| consequence) |
| self.assertEqual( |
| 'Do not use status:New if there is an owner', |
| warning) |
| |
| def testDeserializeRuleConsequence_Error(self): |
| consequence = ('error:Pri-0 issues require an owner') |
| (_status, _owner_id, _cc_ids, _labels, _notify, |
| _warning, error) = self.features_service._DeserializeRuleConsequence( |
| consequence) |
| self.assertEqual( |
| 'Pri-0 issues require an owner', |
| error) |
| |
| def SetUpGetFilterRulesByProjectIDs(self): |
| filterrule_rows = [ |
| (12345, 0, 'predicate1', 'default_status:New'), |
| (12345, 1, 'predicate2', 'default_owner_id:1 add_cc_id:2'), |
| ] |
| |
| self.features_service.filterrule_tbl.Select( |
| self.cnxn, cols=features_svc.FILTERRULE_COLS, |
| project_id=[12345]).AndReturn(filterrule_rows) |
| |
| def testGetFilterRulesByProjectIDs(self): |
| self.SetUpGetFilterRulesByProjectIDs() |
| self.mox.ReplayAll() |
| result = self.features_service._GetFilterRulesByProjectIDs( |
| self.cnxn, [12345]) |
| self.mox.VerifyAll() |
| self.assertIn(12345, result) |
| self.assertEqual(2, len(result[12345])) |
| |
| def testGetFilterRules(self): |
| self.SetUpGetFilterRulesByProjectIDs() |
| self.mox.ReplayAll() |
| result = self.features_service.GetFilterRules( |
| self.cnxn, 12345) |
| self.mox.VerifyAll() |
| self.assertEqual(2, len(result)) |
| |
| def testSerializeRuleConsequence(self): |
| rule = filterrules_helpers.MakeRule( |
| 'predicate', 'New', 1, [1, 2], ['label1', 'label2'], ['admin']) |
| result = self.features_service._SerializeRuleConsequence(rule) |
| self.assertEqual('add_label:label1 add_label:label2 default_status:New' |
| ' default_owner_id:1 add_cc_id:1 add_cc_id:2' |
| ' add_notify:admin', result) |
| |
| def testUpdateFilterRules(self): |
| self.features_service.filterrule_tbl.Delete(self.cnxn, project_id=12345) |
| rows = [ |
| (12345, 0, 'predicate1', 'add_label:label1 add_label:label2' |
| ' default_status:New default_owner_id:1' |
| ' add_cc_id:1 add_cc_id:2 add_notify:admin'), |
| (12345, 1, 'predicate2', 'add_label:label2 add_label:label3' |
| ' default_status:Fixed default_owner_id:2' |
| ' add_cc_id:1 add_cc_id:2 add_notify:admin2') |
| ] |
| self.features_service.filterrule_tbl.InsertRows( |
| self.cnxn, features_svc.FILTERRULE_COLS, rows) |
| rule1 = filterrules_helpers.MakeRule( |
| 'predicate1', 'New', 1, [1, 2], ['label1', 'label2'], ['admin']) |
| rule2 = filterrules_helpers.MakeRule( |
| 'predicate2', 'Fixed', 2, [1, 2], ['label2', 'label3'], ['admin2']) |
| self.mox.ReplayAll() |
| self.features_service.UpdateFilterRules( |
| self.cnxn, 12345, [rule1, rule2]) |
| self.mox.VerifyAll() |
| |
| def testExpungeFilterRules(self): |
| self.features_service.filterrule_tbl.Delete(self.cnxn, project_id=12345) |
| self.mox.ReplayAll() |
| self.features_service.ExpungeFilterRules( |
| self.cnxn, 12345) |
| self.mox.VerifyAll() |
| |
| def testExpungeFilterRulesByUser(self): |
| emails = {'chicken@farm.test': 333, 'cow@fart.test': 222} |
| project_1_keep_rows = [ |
| (1, 1, 'label:no-match-here', 'add_label:should-be-deleted-inserted')] |
| project_16_keep_rows =[ |
| (16, 20, 'label:no-match-here', 'add_label:should-be-deleted-inserted'), |
| (16, 21, 'owner:rainbow@test.com', 'add_label:delete-and-insert')] |
| random_row = [ |
| (19, 9, 'label:no-match-in-project', 'add_label:no-DELETE-INSERTROW')] |
| rows_to_delete = [ |
| (1, 45, 'owner:cow@fart.test', 'add_label:happy-cows'), |
| (1, 46, 'owner:cow@fart.test', 'add_label:balloon'), |
| (16, 47, 'label:queue-eggs', 'add_notify:chicken@farm.test'), |
| (17, 48, 'owner:farmer@farm.test', 'add_cc_id:111 add_cc_id:222'), |
| (17, 48, 'label:queue-chickens', 'default_owner_id:333'), |
| ] |
| rows = (rows_to_delete + project_1_keep_rows + project_16_keep_rows + |
| random_row) |
| self.features_service.filterrule_tbl.Select = mock.Mock(return_value=rows) |
| self.features_service.filterrule_tbl.Delete = mock.Mock() |
| |
| rules_dict = self.features_service.ExpungeFilterRulesByUser( |
| self.cnxn, emails) |
| expected_dict = { |
| 1: [tracker_pb2.FilterRule( |
| predicate=rows[0][2], add_labels=['happy-cows']), |
| tracker_pb2.FilterRule( |
| predicate=rows[1][2], add_labels=['balloon'])], |
| 16: [tracker_pb2.FilterRule( |
| predicate=rows[2][2], add_notify_addrs=['chicken@farm.test'])], |
| 17: [tracker_pb2.FilterRule( |
| predicate=rows[3][2], add_cc_ids=[111, 222])], |
| } |
| self.assertItemsEqual(rules_dict, expected_dict) |
| |
| self.features_service.filterrule_tbl.Select.assert_called_once_with( |
| self.cnxn, features_svc.FILTERRULE_COLS) |
| |
| calls = [mock.call(self.cnxn, project_id=project_id, rank=rank, |
| predicate=predicate, consequence=consequence, |
| commit=False) |
| for (project_id, rank, predicate, consequence) in rows_to_delete] |
| self.features_service.filterrule_tbl.Delete.assert_has_calls( |
| calls, any_order=True) |
| |
| def testExpungeFilterRulesByUser_EmptyUsers(self): |
| self.features_service.filterrule_tbl.Select = mock.Mock() |
| self.features_service.filterrule_tbl.Delete = mock.Mock() |
| |
| rules_dict = self.features_service.ExpungeFilterRulesByUser(self.cnxn, {}) |
| self.assertEqual(rules_dict, {}) |
| self.features_service.filterrule_tbl.Select.assert_not_called() |
| self.features_service.filterrule_tbl.Delete.assert_not_called() |
| |
| def testExpungeFilterRulesByUser_NoMatch(self): |
| rows = [ |
| (17, 48, 'owner:farmer@farm.test', 'add_cc_id:111 add_cc_id: 222'), |
| (19, 9, 'label:no-match-in-project', 'add_label:no-DELETE-INSERTROW'), |
| ] |
| self.features_service.filterrule_tbl.Select = mock.Mock(return_value=rows) |
| self.features_service.filterrule_tbl.Delete = mock.Mock() |
| |
| emails = {'cow@fart.test': 222} |
| rules_dict = self.features_service.ExpungeFilterRulesByUser( |
| self.cnxn, emails) |
| self.assertItemsEqual(rules_dict, {}) |
| |
| self.features_service.filterrule_tbl.Select.assert_called_once_with( |
| self.cnxn, features_svc.FILTERRULE_COLS) |
| self.features_service.filterrule_tbl.Delete.assert_not_called() |
| |
| ### Hotlists |
| |
| def SetUpCreateHotlist(self): |
| # Check for the existing hotlist: there should be none. |
| # Two hotlists named 'hot1' exist but neither are owned by the user. |
| self.features_service.hotlist2user_tbl.Select( |
| self.cnxn, cols=['hotlist_id', 'user_id'], |
| user_id=[567], role_name='owner').AndReturn([]) |
| |
| self.features_service.hotlist_tbl.Select( |
| self.cnxn, cols=['id', 'name'], id=[], is_deleted=False, |
| where =[(('LOWER(name) IN (%s)'), ['hot1'])]).AndReturn([]) |
| |
| # Inserting the hotlist returns the id. |
| self.features_service.hotlist_tbl.InsertRow( |
| self.cnxn, name='hot1', summary='hot 1', description='test hotlist', |
| is_private=False, |
| default_col_spec=features_constants.DEFAULT_COL_SPEC).AndReturn(123) |
| |
| # Insert the issues: there are none. |
| self.features_service.hotlist2issue_tbl.InsertRows( |
| self.cnxn, features_svc.HOTLIST2ISSUE_COLS, |
| [], commit=False) |
| |
| # Insert the users: there is one owner and one editor. |
| self.features_service.hotlist2user_tbl.InsertRows( |
| self.cnxn, ['hotlist_id', 'user_id', 'role_name'], |
| [(123, 567, 'owner'), (123, 678, 'editor')]) |
| |
| def testCreateHotlist(self): |
| self.SetUpCreateHotlist() |
| self.mox.ReplayAll() |
| self.features_service.CreateHotlist( |
| self.cnxn, 'hot1', 'hot 1', 'test hotlist', [567], [678]) |
| self.mox.VerifyAll() |
| |
| def testCreateHotlist_InvalidName(self): |
| with self.assertRaises(exceptions.InputException): |
| self.features_service.CreateHotlist( |
| self.cnxn, '***Invalid name***', 'Misnamed Hotlist', |
| 'A Hotlist with an invalid name', [567], [678]) |
| |
| def testCreateHotlist_NoOwner(self): |
| with self.assertRaises(features_svc.UnownedHotlistException): |
| self.features_service.CreateHotlist( |
| self.cnxn, 'unowned-hotlist', 'Unowned Hotlist', |
| 'A Hotlist that is not owned', [], []) |
| |
| def testCreateHotlist_HotlistAlreadyExists(self): |
| self.features_service.hotlist_id_2lc.CacheItem(('fake-hotlist', 567), 123) |
| with self.assertRaises(features_svc.HotlistAlreadyExists): |
| self.features_service.CreateHotlist( |
| self.cnxn, 'Fake-Hotlist', 'Misnamed Hotlist', |
| 'This name is already in use', [567], [678]) |
| |
| def testTransferHotlistOwnership(self): |
| hotlist_id = 123 |
| new_owner_id = 222 |
| hotlist = fake.Hotlist(hotlist_name='unique', hotlist_id=hotlist_id, |
| owner_ids=[111], editor_ids=[222, 333], |
| follower_ids=[444]) |
| # LookupHotlistIDs, proposed new owner, owns no hotlist with the same name. |
| self.features_service.hotlist2user_tbl.Select = mock.Mock( |
| return_value=[(223, new_owner_id), (567, new_owner_id)]) |
| self.features_service.hotlist_tbl.Select = mock.Mock(return_value=[]) |
| |
| # UpdateHotlistRoles |
| self.features_service.GetHotlist = mock.Mock(return_value=hotlist) |
| self.features_service.hotlist2user_tbl.Delete = mock.Mock() |
| self.features_service.hotlist2user_tbl.InsertRows = mock.Mock() |
| |
| self.features_service.TransferHotlistOwnership( |
| self.cnxn, hotlist, new_owner_id, True) |
| |
| self.features_service.hotlist2user_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=hotlist_id, commit=False) |
| |
| self.features_service.GetHotlist.assert_called_once_with( |
| self.cnxn, hotlist_id, use_cache=False) |
| insert_rows = [(hotlist_id, new_owner_id, 'owner'), |
| (hotlist_id, 333, 'editor'), |
| (hotlist_id, 111, 'editor'), |
| (hotlist_id, 444, 'follower')] |
| self.features_service.hotlist2user_tbl.InsertRows.assert_called_once_with( |
| self.cnxn, features_svc.HOTLIST2USER_COLS, insert_rows, commit=False) |
| |
| def testLookupHotlistIDs(self): |
| # Set up DB query mocks. |
| self.features_service.hotlist2user_tbl.Select = mock.Mock(return_value=[ |
| (123, 222), (125, 333)]) |
| self.features_service.hotlist_tbl.Select = mock.Mock( |
| return_value=[(123, 'q3-TODO'), (125, 'q4-TODO')]) |
| |
| self.features_service.hotlist_id_2lc.CacheItem( |
| ('q4-todo', 333), 124) |
| |
| ret = self.features_service.LookupHotlistIDs( |
| self.cnxn, ['q3-todo', 'Q4-TODO'], [222, 333, 444]) |
| self.assertEqual(ret, {('q3-todo', 222) : 123, ('q4-todo', 333): 124}) |
| self.features_service.hotlist2user_tbl.Select.assert_called_once_with( |
| self.cnxn, cols=['hotlist_id', 'user_id'], user_id=[444, 333, 222], |
| role_name='owner') |
| self.features_service.hotlist_tbl.Select.assert_called_once_with( |
| self.cnxn, cols=['id', 'name'], id=[123, 125], is_deleted=False, |
| where=[ |
| (('LOWER(name) IN (%s,%s)'), ['q3-todo', 'q4-todo'])]) |
| |
| def SetUpLookupUserHotlists(self): |
| self.features_service.hotlist2user_tbl.Select( |
| self.cnxn, cols=['user_id', 'hotlist_id'], |
| user_id=[111], left_joins=[('Hotlist ON hotlist_id = id', [])], |
| where=[('Hotlist.is_deleted = %s', [False])]).AndReturn([(111, 123)]) |
| |
| def testLookupUserHotlists(self): |
| self.SetUpLookupUserHotlists() |
| self.mox.ReplayAll() |
| ret = self.features_service.LookupUserHotlists( |
| self.cnxn, [111]) |
| self.assertEqual(ret, {111: [123]}) |
| self.mox.VerifyAll() |
| |
| def SetUpLookupIssueHotlists(self): |
| self.features_service.hotlist2issue_tbl.Select( |
| self.cnxn, cols=['hotlist_id', 'issue_id'], |
| issue_id=[987], left_joins=[('Hotlist ON hotlist_id = id', [])], |
| where=[('Hotlist.is_deleted = %s', [False])]).AndReturn([(123, 987)]) |
| |
| def testLookupIssueHotlists(self): |
| self.SetUpLookupIssueHotlists() |
| self.mox.ReplayAll() |
| ret = self.features_service.LookupIssueHotlists( |
| self.cnxn, [987]) |
| self.assertEqual(ret, {987: [123]}) |
| self.mox.VerifyAll() |
| |
| def SetUpGetHotlists( |
| self, hotlist_id, hotlist_rows=None, issue_rows=None, role_rows=None): |
| if not hotlist_rows: |
| hotlist_rows = [(hotlist_id, 'hotlist2', 'test hotlist 2', |
| 'test hotlist', False, '')] |
| if not issue_rows: |
| issue_rows=[] |
| if not role_rows: |
| role_rows=[] |
| self.features_service.hotlist_tbl.Select( |
| self.cnxn, cols=features_svc.HOTLIST_COLS, |
| id=[hotlist_id], is_deleted=False).AndReturn(hotlist_rows) |
| self.features_service.hotlist2user_tbl.Select( |
| self.cnxn, cols=['hotlist_id', 'user_id', 'role_name'], |
| hotlist_id=[hotlist_id]).AndReturn(role_rows) |
| self.features_service.hotlist2issue_tbl.Select( |
| self.cnxn, cols=features_svc.HOTLIST2ISSUE_COLS, |
| hotlist_id=[hotlist_id], |
| order_by=[('rank DESC', []), ('issue_id', [])]).AndReturn(issue_rows) |
| |
| def SetUpUpdateHotlist(self, hotlist_id): |
| hotlist_rows = [ |
| (hotlist_id, 'hotlist2', 'test hotlist 2', 'test hotlist', False, '') |
| ] |
| role_rows = [(hotlist_id, 111, 'owner')] |
| |
| self.features_service.hotlist_tbl.Select = mock.Mock( |
| return_value=hotlist_rows) |
| self.features_service.hotlist2user_tbl.Select = mock.Mock( |
| return_value=role_rows) |
| self.features_service.hotlist2issue_tbl.Select = mock.Mock(return_value=[]) |
| |
| self.features_service.hotlist_tbl.Update = mock.Mock() |
| self.features_service.hotlist2user_tbl.Delete = mock.Mock() |
| self.features_service.hotlist2user_tbl.InsertRows = mock.Mock() |
| |
| def testUpdateHotlist(self): |
| hotlist_id = 456 |
| self.SetUpUpdateHotlist(hotlist_id) |
| |
| self.features_service.UpdateHotlist( |
| self.cnxn, |
| hotlist_id, |
| summary='A better one-line summary', |
| owner_id=333, |
| add_editor_ids=[444, 555]) |
| delta = {'summary': 'A better one-line summary'} |
| self.features_service.hotlist_tbl.Update.assert_called_once_with( |
| self.cnxn, delta, id=hotlist_id, commit=False) |
| self.features_service.hotlist2user_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=hotlist_id, role='owner', commit=False) |
| add_role_rows = [ |
| (hotlist_id, 333, 'owner'), (hotlist_id, 444, 'editor'), |
| (hotlist_id, 555, 'editor') |
| ] |
| self.features_service.hotlist2user_tbl.InsertRows.assert_called_once_with( |
| self.cnxn, features_svc.HOTLIST2USER_COLS, add_role_rows, commit=False) |
| |
| def testUpdateHotlist_NoRoleChanges(self): |
| hotlist_id = 456 |
| self.SetUpUpdateHotlist(hotlist_id) |
| |
| self.features_service.UpdateHotlist(self.cnxn, hotlist_id, name='chicken') |
| delta = {'name': 'chicken'} |
| self.features_service.hotlist_tbl.Update.assert_called_once_with( |
| self.cnxn, delta, id=hotlist_id, commit=False) |
| self.features_service.hotlist2user_tbl.Delete.assert_not_called() |
| self.features_service.hotlist2user_tbl.InsertRows.assert_not_called() |
| |
| def testUpdateHotlist_NoOwnerChange(self): |
| hotlist_id = 456 |
| self.SetUpUpdateHotlist(hotlist_id) |
| |
| self.features_service.UpdateHotlist( |
| self.cnxn, hotlist_id, name='chicken', add_editor_ids=[ |
| 333, |
| ]) |
| delta = {'name': 'chicken'} |
| self.features_service.hotlist_tbl.Update.assert_called_once_with( |
| self.cnxn, delta, id=hotlist_id, commit=False) |
| self.features_service.hotlist2user_tbl.Delete.assert_not_called() |
| self.features_service.hotlist2user_tbl.InsertRows.assert_called_once_with( |
| self.cnxn, |
| features_svc.HOTLIST2USER_COLS, [ |
| (hotlist_id, 333, 'editor'), |
| ], |
| commit=False) |
| |
| def SetUpRemoveHotlistEditors(self): |
| hotlist = fake.Hotlist( |
| hotlist_name='hotlist', |
| hotlist_id=456, |
| owner_ids=[111], |
| editor_ids=[222, 333, 444]) |
| self.features_service.GetHotlist = mock.Mock(return_value=hotlist) |
| self.features_service.hotlist2user_tbl.Delete = mock.Mock() |
| return hotlist |
| |
| def testRemoveHotlistEditors(self): |
| """We can remove editors from a hotlist.""" |
| hotlist = self.SetUpRemoveHotlistEditors() |
| remove_editor_ids = [222, 333] |
| self.features_service.RemoveHotlistEditors( |
| self.cnxn, hotlist.hotlist_id, remove_editor_ids=remove_editor_ids) |
| self.features_service.hotlist2user_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=hotlist.hotlist_id, user_id=remove_editor_ids) |
| self.assertEqual(hotlist.editor_ids, [444]) |
| |
| def testRemoveHotlistEditors_NoOp(self): |
| """A NoOp update does not trigger and sql table calls.""" |
| hotlist = self.SetUpRemoveHotlistEditors() |
| with self.assertRaises(exceptions.InputException): |
| self.features_service.RemoveHotlistEditors( |
| self.cnxn, hotlist.hotlist_id, remove_editor_ids=[]) |
| |
| def SetUpUpdateHotlistItemsFields(self, hotlist_id, issue_ids): |
| hotlist_rows = [(hotlist_id, 'hotlist', '', '', True, '')] |
| insert_rows = [(345, 11, 112, 333, 2002, ''), |
| (345, 33, 332, 333, 2002, ''), |
| (345, 55, 552, 333, 2002, '')] |
| issue_rows = [(345, 11, 1, 333, 2002, ''), (345, 33, 3, 333, 2002, ''), |
| (345, 55, 3, 333, 2002, '')] |
| self.SetUpGetHotlists( |
| hotlist_id, hotlist_rows=hotlist_rows, issue_rows=issue_rows) |
| self.features_service.hotlist2issue_tbl.Delete( |
| self.cnxn, hotlist_id=hotlist_id, |
| issue_id=issue_ids, commit=False) |
| self.features_service.hotlist2issue_tbl.InsertRows( |
| self.cnxn, cols=features_svc.HOTLIST2ISSUE_COLS, |
| row_values=insert_rows, commit=True) |
| |
| def testUpdateHotlistItemsFields_Ranks(self): |
| hotlist_item_fields = [ |
| (11, 1, 333, 2002, ''), (33, 3, 333, 2002, ''), |
| (55, 3, 333, 2002, '')] |
| hotlist = fake.Hotlist(hotlist_name='hotlist', hotlist_id=345, |
| hotlist_item_fields=hotlist_item_fields) |
| self.features_service.hotlist_2lc.CacheItem(345, hotlist) |
| relations_to_change = {11: 112, 33: 332, 55: 552} |
| issue_ids = [11, 33, 55] |
| self.SetUpUpdateHotlistItemsFields(345, issue_ids) |
| self.mox.ReplayAll() |
| self.features_service.UpdateHotlistItemsFields( |
| self.cnxn, 345, new_ranks=relations_to_change) |
| self.mox.VerifyAll() |
| |
| def testUpdateHotlistItemsFields_Notes(self): |
| pass |
| |
| def testGetHotlists(self): |
| hotlist1 = fake.Hotlist(hotlist_name='hotlist1', hotlist_id=123) |
| self.features_service.hotlist_2lc.CacheItem(123, hotlist1) |
| self.SetUpGetHotlists(456) |
| self.mox.ReplayAll() |
| hotlist_dict = self.features_service.GetHotlists( |
| self.cnxn, [123, 456]) |
| self.mox.VerifyAll() |
| self.assertItemsEqual([123, 456], list(hotlist_dict.keys())) |
| self.assertEqual('hotlist1', hotlist_dict[123].name) |
| self.assertEqual('hotlist2', hotlist_dict[456].name) |
| |
| def testGetHotlistsByID(self): |
| hotlist1 = fake.Hotlist(hotlist_name='hotlist1', hotlist_id=123) |
| self.features_service.hotlist_2lc.CacheItem(123, hotlist1) |
| # NOTE: The setup function must take a hotlist_id that is different |
| # from what was used in previous tests, otherwise the methods in the |
| # setup function will never get called. |
| self.SetUpGetHotlists(456) |
| self.mox.ReplayAll() |
| _, actual_missed = self.features_service.GetHotlistsByID( |
| self.cnxn, [123, 456]) |
| self.mox.VerifyAll() |
| self.assertEqual(actual_missed, []) |
| |
| def testGetHotlistsByUserID(self): |
| self.SetUpLookupUserHotlists() |
| self.SetUpGetHotlists(123) |
| self.mox.ReplayAll() |
| hotlists = self.features_service.GetHotlistsByUserID(self.cnxn, 111) |
| self.assertEqual(len(hotlists), 1) |
| self.assertEqual(hotlists[0].hotlist_id, 123) |
| self.mox.VerifyAll() |
| |
| def testGetHotlistsByIssueID(self): |
| self.SetUpLookupIssueHotlists() |
| self.SetUpGetHotlists(123) |
| self.mox.ReplayAll() |
| hotlists = self.features_service.GetHotlistsByIssueID(self.cnxn, 987) |
| self.assertEqual(len(hotlists), 1) |
| self.assertEqual(hotlists[0].hotlist_id, 123) |
| self.mox.VerifyAll() |
| |
| def SetUpUpdateHotlistRoles( |
| self, hotlist_id, owner_ids, editor_ids, follower_ids): |
| |
| self.features_service.hotlist2user_tbl.Delete( |
| self.cnxn, hotlist_id=hotlist_id, commit=False) |
| |
| insert_rows = [(hotlist_id, user_id, 'owner') for user_id in owner_ids] |
| insert_rows.extend( |
| [(hotlist_id, user_id, 'editor') for user_id in editor_ids]) |
| insert_rows.extend( |
| [(hotlist_id, user_id, 'follower') for user_id in follower_ids]) |
| self.features_service.hotlist2user_tbl.InsertRows( |
| self.cnxn, ['hotlist_id', 'user_id', 'role_name'], |
| insert_rows, commit=False) |
| |
| self.cnxn.Commit() |
| |
| def testUpdateHotlistRoles(self): |
| self.SetUpGetHotlists(456) |
| self.SetUpUpdateHotlistRoles(456, [111, 222], [333], []) |
| self.mox.ReplayAll() |
| self.features_service.UpdateHotlistRoles( |
| self.cnxn, 456, [111, 222], [333], []) |
| self.mox.VerifyAll() |
| |
| def SetUpUpdateHotlistIssues(self, items): |
| hotlist = fake.Hotlist(hotlist_name='hotlist', hotlist_id=456) |
| hotlist.items = items |
| self.features_service.GetHotlist = mock.Mock(return_value=hotlist) |
| self.features_service.hotlist2issue_tbl.Delete = mock.Mock() |
| self.features_service.hotlist2issue_tbl.InsertRows = mock.Mock() |
| self.issue_service.GetIssues = mock.Mock() |
| return hotlist |
| |
| def testUpdateHotlistIssues_ChangeIssues(self): |
| original_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=11, adder_id=333, date_added=2345), # update |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345) # same |
| ] |
| hotlist = self.SetUpUpdateHotlistIssues(original_items) |
| updated_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=13, adder_id=333, date_added=2345), # update |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78903, rank=23, adder_id=333, date_added=2345) # new |
| ] |
| |
| self.features_service.UpdateHotlistIssues( |
| self.cnxn, hotlist.hotlist_id, updated_items, [], self.issue_service, |
| self.chart_service) |
| |
| insert_rows = [ |
| (hotlist.hotlist_id, 78902, 13, 333, 2345, ''), |
| (hotlist.hotlist_id, 78903, 23, 333, 2345, '') |
| ] |
| self.features_service.hotlist2issue_tbl.InsertRows.assert_called_once_with( |
| self.cnxn, |
| cols=features_svc.HOTLIST2ISSUE_COLS, |
| row_values=insert_rows, |
| commit=False) |
| self.features_service.hotlist2issue_tbl.Delete.assert_called_once_with( |
| self.cnxn, |
| hotlist_id=hotlist.hotlist_id, |
| issue_id=[78902, 78903], |
| commit=False) |
| |
| # New hotlist itmes includes updated_items and unchanged items. |
| expected_all_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345), |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=13, adder_id=333, date_added=2345), |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78903, rank=23, adder_id=333, date_added=2345) |
| ] |
| self.assertEqual(hotlist.items, expected_all_items) |
| |
| # Assert we're storing the new snapshots of the affected issues. |
| self.issue_service.GetIssues.assert_called_once_with( |
| self.cnxn, [78902, 78903]) |
| |
| def testUpdateHotlistIssues_RemoveIssues(self): |
| original_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78901, rank=10, adder_id=222, date_added=2348), # remove |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345), # same |
| ] |
| hotlist = self.SetUpUpdateHotlistIssues(original_items) |
| remove_issue_ids = [78901] |
| |
| self.features_service.UpdateHotlistIssues( |
| self.cnxn, hotlist.hotlist_id, [], remove_issue_ids, self.issue_service, |
| self.chart_service) |
| |
| self.features_service.hotlist2issue_tbl.Delete.assert_called_once_with( |
| self.cnxn, |
| hotlist_id=hotlist.hotlist_id, |
| issue_id=remove_issue_ids, |
| commit=False) |
| |
| # New hotlist itmes includes updated_items and unchanged items. |
| expected_all_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345) |
| ] |
| self.assertEqual(hotlist.items, expected_all_items) |
| |
| # Assert we're storing the new snapshots of the affected issues. |
| self.issue_service.GetIssues.assert_called_once_with(self.cnxn, [78901]) |
| |
| def testUpdateHotlistIssues_RemoveAndChange(self): |
| original_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78901, rank=10, adder_id=222, date_added=2348), # remove |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=11, adder_id=333, date_added=2345), # update |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345) # same |
| ] |
| hotlist = self.SetUpUpdateHotlistIssues(original_items) |
| # test 78902 gets added back with `updated_items` |
| remove_issue_ids = [78901, 78902] |
| updated_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=13, adder_id=333, date_added=2345), |
| ] |
| |
| self.features_service.UpdateHotlistIssues( |
| self.cnxn, hotlist.hotlist_id, updated_items, remove_issue_ids, |
| self.issue_service, self.chart_service) |
| |
| delete_calls = [ |
| mock.call( |
| self.cnxn, |
| hotlist_id=hotlist.hotlist_id, |
| issue_id=remove_issue_ids, |
| commit=False), |
| mock.call( |
| self.cnxn, |
| hotlist_id=hotlist.hotlist_id, |
| issue_id=[78902], |
| commit=False) |
| ] |
| self.assertEqual( |
| self.features_service.hotlist2issue_tbl.Delete.mock_calls, delete_calls) |
| |
| insert_rows = [ |
| (hotlist.hotlist_id, 78902, 13, 333, 2345, ''), |
| ] |
| self.features_service.hotlist2issue_tbl.InsertRows.assert_called_once_with( |
| self.cnxn, |
| cols=features_svc.HOTLIST2ISSUE_COLS, |
| row_values=insert_rows, |
| commit=False) |
| |
| # New hotlist itmes includes updated_items and unchanged items. |
| expected_all_items = [ |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78904, rank=0, adder_id=333, date_added=2345), |
| features_pb2.Hotlist.HotlistItem( |
| issue_id=78902, rank=13, adder_id=333, date_added=2345), |
| ] |
| self.assertEqual(hotlist.items, expected_all_items) |
| |
| # Assert we're storing the new snapshots of the affected issues. |
| self.issue_service.GetIssues.assert_called_once_with( |
| self.cnxn, [78901, 78902]) |
| |
| def testUpdateHotlistIssues_NoChanges(self): |
| with self.assertRaises(exceptions.InputException): |
| self.features_service.UpdateHotlistIssues( |
| self.cnxn, 456, [], None, self.issue_service, self.chart_service) |
| |
| def SetUpUpdateHotlistItems(self, cnxn, hotlist_id, remove, added_tuples): |
| self.features_service.hotlist2issue_tbl.Delete( |
| cnxn, hotlist_id=hotlist_id, issue_id=remove, commit=False) |
| rank = 1 |
| added_tuples_with_rank = [(issue_id, rank+10*mult, user_id, ts, note) for |
| mult, (issue_id, user_id, ts, note) in |
| enumerate(added_tuples)] |
| insert_rows = [(hotlist_id, issue_id, |
| rank, user_id, date, note) for |
| (issue_id, rank, user_id, date, note) in |
| added_tuples_with_rank] |
| self.features_service.hotlist2issue_tbl.InsertRows( |
| cnxn, cols=features_svc.HOTLIST2ISSUE_COLS, |
| row_values=insert_rows, commit=False) |
| |
| def testAddIssuesToHotlists(self): |
| added_tuples = [ |
| (111, None, None, ''), |
| (222, None, None, ''), |
| (333, None, None, '')] |
| issues = [ |
| tracker_pb2.Issue(issue_id=issue_id) |
| for issue_id, _, _, _ in added_tuples |
| ] |
| self.SetUpGetHotlists(456) |
| self.SetUpUpdateHotlistItems( |
| self.cnxn, 456, [], added_tuples) |
| self.SetUpGetHotlists(567) |
| self.SetUpUpdateHotlistItems( |
| self.cnxn, 567, [], added_tuples) |
| |
| self.mox.StubOutWithMock(self.issue_service, 'GetIssues') |
| self.issue_service.GetIssues(self.cnxn, |
| [111, 222, 333]).AndReturn(issues) |
| self.chart_service.StoreIssueSnapshots(self.cnxn, issues, |
| commit=False) |
| self.mox.ReplayAll() |
| self.features_service.AddIssuesToHotlists( |
| self.cnxn, [456, 567], added_tuples, self.issue_service, |
| self.chart_service, commit=False) |
| self.mox.VerifyAll() |
| |
| def testRemoveIssuesFromHotlists(self): |
| issue_rows = [ |
| (456, 555, 1, None, None, ''), |
| (456, 666, 11, None, None, ''), |
| ] |
| issues = [tracker_pb2.Issue(issue_id=issue_rows[0][1])] |
| self.SetUpGetHotlists(456, issue_rows=issue_rows) |
| self.SetUpUpdateHotlistItems( |
| self. cnxn, 456, [555], []) |
| issue_rows = [ |
| (789, 555, 1, None, None, ''), |
| (789, 666, 11, None, None, ''), |
| ] |
| self.SetUpGetHotlists(789, issue_rows=issue_rows) |
| self.SetUpUpdateHotlistItems( |
| self. cnxn, 789, [555], []) |
| self.mox.StubOutWithMock(self.issue_service, 'GetIssues') |
| self.issue_service.GetIssues(self.cnxn, |
| [555]).AndReturn(issues) |
| self.chart_service.StoreIssueSnapshots(self.cnxn, issues, commit=False) |
| self.mox.ReplayAll() |
| self.features_service.RemoveIssuesFromHotlists( |
| self.cnxn, [456, 789], [555], self.issue_service, self.chart_service, |
| commit=False) |
| self.mox.VerifyAll() |
| |
| def testUpdateHotlistItems(self): |
| self.SetUpGetHotlists(456) |
| self.SetUpUpdateHotlistItems( |
| self. cnxn, 456, [], [ |
| (111, None, None, ''), |
| (222, None, None, ''), |
| (333, None, None, '')]) |
| self.mox.ReplayAll() |
| self.features_service.UpdateHotlistItems( |
| self.cnxn, 456, [], |
| [(111, None, None, ''), |
| (222, None, None, ''), |
| (333, None, None, '')], commit=False) |
| self.mox.VerifyAll() |
| |
| def SetUpDeleteHotlist(self, cnxn, hotlist_id): |
| hotlist_rows = [(hotlist_id, 'hotlist', 'test hotlist', |
| 'test list', False, '')] |
| self.SetUpGetHotlists(678, hotlist_rows=hotlist_rows, |
| role_rows=[(hotlist_id, 111, 'owner', )]) |
| self.features_service.hotlist2issue_tbl.Select(self.cnxn, |
| cols=['Issue.project_id'], hotlist_id=hotlist_id, distinct=True, |
| left_joins=[('Issue ON issue_id = id', [])]).AndReturn([(1,)]) |
| self.features_service.hotlist_tbl.Update(cnxn, {'is_deleted': True}, |
| commit=False, id=hotlist_id) |
| |
| def testDeleteHotlist(self): |
| self.SetUpDeleteHotlist(self.cnxn, 678) |
| self.mox.ReplayAll() |
| self.features_service.DeleteHotlist(self.cnxn, 678, commit=False) |
| self.mox.VerifyAll() |
| |
| def testExpungeHotlists(self): |
| hotliststar_tbl = mock.Mock() |
| star_service = star_svc.AbstractStarService( |
| self.cache_manager, hotliststar_tbl, 'hotlist_id', 'user_id', 'hotlist') |
| hotliststar_tbl.Delete = mock.Mock() |
| user_service = user_svc.UserService(self.cache_manager) |
| user_service.hotlistvisithistory_tbl.Delete = mock.Mock() |
| chart_service = chart_svc.ChartService(self.config_service) |
| self.cnxn.Execute = mock.Mock() |
| |
| hotlist1 = fake.Hotlist(hotlist_name='unique', hotlist_id=678, |
| owner_ids=[111], editor_ids=[222, 333]) |
| hotlist2 = fake.Hotlist(hotlist_name='unique2', hotlist_id=679, |
| owner_ids=[111]) |
| hotlists_by_id = {hotlist1.hotlist_id: hotlist1, |
| hotlist2.hotlist_id: hotlist2} |
| self.features_service.GetHotlists = mock.Mock(return_value=hotlists_by_id) |
| self.features_service.hotlist2user_tbl.Delete = mock.Mock() |
| self.features_service.hotlist2issue_tbl.Delete = mock.Mock() |
| self.features_service.hotlist_tbl.Delete = mock.Mock() |
| # cache invalidation mocks |
| self.features_service.hotlist_2lc.InvalidateKeys = mock.Mock() |
| self.features_service.hotlist_id_2lc.InvalidateKeys = mock.Mock() |
| self.features_service.hotlist_user_to_ids.InvalidateKeys = mock.Mock() |
| self.config_service.InvalidateMemcacheForEntireProject = mock.Mock() |
| |
| hotlists_project_id = 787 |
| self.features_service.GetProjectIDsFromHotlist = mock.Mock( |
| return_value=[hotlists_project_id]) |
| |
| hotlist_ids = hotlists_by_id.keys() |
| commit = True # commit in ExpungeHotlists should be True by default. |
| self.features_service.ExpungeHotlists( |
| self.cnxn, hotlist_ids, star_service, user_service, chart_service) |
| |
| star_calls = [ |
| mock.call( |
| self.cnxn, commit=commit, limit=None, hotlist_id=hotlist_ids[0]), |
| mock.call( |
| self.cnxn, commit=commit, limit=None, hotlist_id=hotlist_ids[1])] |
| hotliststar_tbl.Delete.assert_has_calls(star_calls) |
| |
| self.cnxn.Execute.assert_called_once_with( |
| 'DELETE FROM IssueSnapshot2Hotlist WHERE hotlist_id IN (%s,%s)', |
| [678, 679], commit=commit) |
| user_service.hotlistvisithistory_tbl.Delete.assert_called_once_with( |
| self.cnxn, commit=commit, hotlist_id=hotlist_ids) |
| |
| self.features_service.hotlist2user_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=hotlist_ids, commit=commit) |
| self.features_service.hotlist2issue_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=hotlist_ids, commit=commit) |
| self.features_service.hotlist_tbl.Delete.assert_called_once_with( |
| self.cnxn, id=hotlist_ids, commit=commit) |
| # cache invalidation checks |
| self.features_service.hotlist_2lc.InvalidateKeys.assert_called_once_with( |
| self.cnxn, hotlist_ids) |
| invalidate_owner_calls = [ |
| mock.call(self.cnxn, [(hotlist1.name, hotlist1.owner_ids[0])]), |
| mock.call(self.cnxn, [(hotlist2.name, hotlist2.owner_ids[0])])] |
| self.features_service.hotlist_id_2lc.InvalidateKeys.assert_has_calls( |
| invalidate_owner_calls) |
| self.features_service.hotlist_user_to_ids.InvalidateKeys.\ |
| assert_called_once_with( |
| self.cnxn, [333, 222, 111]) |
| self.config_service.InvalidateMemcacheForEntireProject.\ |
| assert_called_once_with(hotlists_project_id) |
| |
| def testExpungeUsersInHotlists(self): |
| hotliststar_tbl = mock.Mock() |
| star_service = star_svc.AbstractStarService( |
| self.cache_manager, hotliststar_tbl, 'hotlist_id', 'user_id', 'hotlist') |
| user_service = user_svc.UserService(self.cache_manager) |
| chart_service = chart_svc.ChartService(self.config_service) |
| user_ids = [111, 222] |
| |
| # hotlist1 will get transferred to 333 |
| hotlist1 = fake.Hotlist(hotlist_name='unique', hotlist_id=123, |
| owner_ids=[111], editor_ids=[222, 333]) |
| # hotlist2 will get deleted |
| hotlist2 = fake.Hotlist(hotlist_name='name', hotlist_id=223, |
| owner_ids=[222], editor_ids=[111, 333]) |
| delete_hotlists = [hotlist2.hotlist_id] |
| delete_hotlist_project_id = 788 |
| self.features_service.GetProjectIDsFromHotlist = mock.Mock( |
| return_value=[delete_hotlist_project_id]) |
| self.config_service.InvalidateMemcacheForEntireProject = mock.Mock() |
| hotlists_by_user_id = { |
| 111: [hotlist1.hotlist_id, hotlist2.hotlist_id], |
| 222: [hotlist1.hotlist_id, hotlist2.hotlist_id], |
| 333: [hotlist1.hotlist_id, hotlist2.hotlist_id]} |
| self.features_service.LookupUserHotlists = mock.Mock( |
| return_value=hotlists_by_user_id) |
| hotlists_by_id = {hotlist1.hotlist_id: hotlist1, |
| hotlist2.hotlist_id: hotlist2} |
| self.features_service.GetHotlistsByID = mock.Mock( |
| return_value=(hotlists_by_id, [])) |
| |
| # User 333 already has a hotlist named 'name'. |
| def side_effect(_cnxn, hotlist_names, owner_ids): |
| if 333 in owner_ids and 'name' in hotlist_names: |
| return {('name', 333): 567} |
| return {} |
| self.features_service.LookupHotlistIDs = mock.Mock( |
| side_effect=side_effect) |
| # Called to transfer hotlist ownership |
| self.features_service.UpdateHotlistRoles = mock.Mock() |
| |
| # Called to expunge users and hotlists |
| self.features_service.hotlist2user_tbl.Delete = mock.Mock() |
| self.features_service.hotlist2issue_tbl.Update = mock.Mock() |
| user_service.hotlistvisithistory_tbl.Delete = mock.Mock() |
| |
| # Called to expunge hotlists |
| hotlists_by_id = {hotlist1.hotlist_id: hotlist1, |
| hotlist2.hotlist_id: hotlist2} |
| self.features_service.GetHotlists = mock.Mock( |
| return_value=hotlists_by_id) |
| self.features_service.hotlist2issue_tbl.Delete = mock.Mock() |
| self.features_service.hotlist_tbl.Delete = mock.Mock() |
| hotliststar_tbl.Delete = mock.Mock() |
| |
| self.features_service.ExpungeUsersInHotlists( |
| self.cnxn, user_ids, star_service, user_service, chart_service) |
| |
| self.features_service.UpdateHotlistRoles.assert_called_once_with( |
| self.cnxn, hotlist1.hotlist_id, [333], [222], [], commit=False) |
| |
| self.features_service.hotlist2user_tbl.Delete.assert_has_calls( |
| [mock.call(self.cnxn, user_id=user_ids, commit=False), |
| mock.call(self.cnxn, hotlist_id=delete_hotlists, commit=False)]) |
| self.features_service.hotlist2issue_tbl.Update.assert_called_once_with( |
| self.cnxn, {'adder_id': framework_constants.DELETED_USER_ID}, |
| adder_id=user_ids, commit=False) |
| user_service.hotlistvisithistory_tbl.Delete.assert_has_calls( |
| [mock.call(self.cnxn, user_id=user_ids, commit=False), |
| mock.call(self.cnxn, hotlist_id=delete_hotlists, commit=False)]) |
| |
| self.features_service.hotlist2issue_tbl.Delete.assert_called_once_with( |
| self.cnxn, hotlist_id=delete_hotlists, commit=False) |
| hotliststar_tbl.Delete.assert_called_once_with( |
| self.cnxn, commit=False, limit=None, hotlist_id=delete_hotlists[0]) |
| self.features_service.hotlist_tbl.Delete.assert_called_once_with( |
| self.cnxn, id=delete_hotlists, commit=False) |
| |
| |
| def testGetProjectIDsFromHotlist(self): |
| self.features_service.hotlist2issue_tbl.Select(self.cnxn, |
| cols=['Issue.project_id'], hotlist_id=678, distinct=True, |
| left_joins=[('Issue ON issue_id = id', [])]).AndReturn( |
| [(789,), (787,), (788,)]) |
| |
| self.mox.ReplayAll() |
| project_ids = self.features_service.GetProjectIDsFromHotlist(self.cnxn, 678) |
| self.mox.VerifyAll() |
| self.assertEqual([789, 787, 788], project_ids) |