OLD | NEW |
(Empty) | |
| 1 # Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 # Use of this source code is govered by a BSD-style |
| 3 # license that can be found in the LICENSE file or at |
| 4 # https://developers.google.com/open-source/licenses/bsd |
| 5 |
| 6 """Tests for the backendsearchpipeline module.""" |
| 7 |
| 8 import mox |
| 9 import unittest |
| 10 |
| 11 from google.appengine.api import memcache |
| 12 from google.appengine.ext import testbed |
| 13 |
| 14 import settings |
| 15 from framework import framework_helpers |
| 16 from framework import profiler |
| 17 from framework import sorting |
| 18 from framework import sql |
| 19 from proto import ast_pb2 |
| 20 from proto import tracker_pb2 |
| 21 from search import backendsearchpipeline |
| 22 from search import ast2ast |
| 23 from search import query2ast |
| 24 from services import service_manager |
| 25 from services import tracker_fulltext |
| 26 from testing import fake |
| 27 from testing import testing_helpers |
| 28 from tracker import tracker_bizobj |
| 29 |
| 30 |
| 31 class BackendSearchPipelineTest(unittest.TestCase): |
| 32 |
| 33 def setUp(self): |
| 34 self.cnxn = 'fake cnxn' |
| 35 self.services = service_manager.Services( |
| 36 user=fake.UserService(), |
| 37 usergroup=fake.UserGroupService(), |
| 38 project=fake.ProjectService(), |
| 39 issue=fake.IssueService(), |
| 40 config=fake.ConfigService(), |
| 41 cache_manager=fake.CacheManager()) |
| 42 self.profiler = profiler.Profiler() |
| 43 self.services.user.TestAddUser('a@example.com', 111L) |
| 44 self.project = self.services.project.TestAddProject('proj', project_id=789) |
| 45 self.mr = testing_helpers.MakeMonorailRequest( |
| 46 path='/p/proj/issues/list?q=Priority:High', |
| 47 project=self.project) |
| 48 self.mr.me_user_id = 999L # This value is not used by backend search |
| 49 self.mr.shard_id = 2 |
| 50 self.mr.invalidation_timestep = 12345 |
| 51 |
| 52 self.mox = mox.Mox() |
| 53 self.testbed = testbed.Testbed() |
| 54 self.testbed.activate() |
| 55 self.testbed.init_user_stub() |
| 56 self.testbed.init_memcache_stub() |
| 57 sorting.InitializeArtValues(self.services) |
| 58 |
| 59 def tearDown(self): |
| 60 self.testbed.deactivate() |
| 61 self.mox.UnsetStubs() |
| 62 self.mox.ResetAll() |
| 63 |
| 64 def SetUpPromises(self, exp_query): |
| 65 self.mox.StubOutWithMock(framework_helpers, 'Promise') |
| 66 framework_helpers.Promise( |
| 67 backendsearchpipeline._GetQueryResultIIDs, self.mr.cnxn, |
| 68 self.services, 'is:open', exp_query, [789], |
| 69 mox.IsA(tracker_pb2.ProjectIssueConfig), ['project', 'id'], |
| 70 ('Issue.shard = %s', [2]), 2, self.mr.invalidation_timestep |
| 71 ).AndReturn('fake promise 1') |
| 72 |
| 73 def testMakePromises_Anon(self): |
| 74 """A backend pipeline does not personalize the query of anon users.""" |
| 75 self.SetUpPromises('Priority:High') |
| 76 self.mox.ReplayAll() |
| 77 backendsearchpipeline.BackendSearchPipeline( |
| 78 self.mr, self.services, self.profiler, 100, ['proj'], None, None) |
| 79 self.mox.VerifyAll() |
| 80 |
| 81 def testMakePromises_SignedIn(self): |
| 82 """A backend pipeline immediately personalizes and runs the query.""" |
| 83 self.mr.query = 'owner:me' |
| 84 self.SetUpPromises('owner:111') |
| 85 self.mox.ReplayAll() |
| 86 backendsearchpipeline.BackendSearchPipeline( |
| 87 self.mr, self.services, self.profiler, 100, ['proj'], 111L, 111L) |
| 88 self.mox.VerifyAll() |
| 89 |
| 90 def testSearchForIIDs(self): |
| 91 self.SetUpPromises('Priority:High') |
| 92 self.mox.ReplayAll() |
| 93 be_pipeline = backendsearchpipeline.BackendSearchPipeline( |
| 94 self.mr, self.services, self.profiler, 100, ['proj'], 111L, 111L) |
| 95 be_pipeline.result_iids_promise = testing_helpers.Blank( |
| 96 WaitAndGetValue=lambda: ([10002, 10052], False)) |
| 97 be_pipeline.SearchForIIDs() |
| 98 self.mox.VerifyAll() |
| 99 self.assertEqual([10002, 10052], be_pipeline.result_iids) |
| 100 self.assertEqual(False, be_pipeline.search_limit_reached) |
| 101 |
| 102 |
| 103 class BackendSearchPipelineMethodsTest(unittest.TestCase): |
| 104 |
| 105 def setUp(self): |
| 106 self.cnxn = 'fake cnxn' |
| 107 self.config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 108 self.services = service_manager.Services( |
| 109 user=fake.UserService(), |
| 110 usergroup=fake.UserGroupService(), |
| 111 project=fake.ProjectService(), |
| 112 issue=fake.IssueService(), |
| 113 config=fake.ConfigService(), |
| 114 cache_manager=fake.CacheManager()) |
| 115 self.profiler = profiler.Profiler() |
| 116 self.services.user.TestAddUser('a@example.com', 111L) |
| 117 self.project = self.services.project.TestAddProject('proj', project_id=789) |
| 118 self.mr = testing_helpers.MakeMonorailRequest( |
| 119 path='/p/proj/issues/list?q=Priority:High', |
| 120 project=self.project) |
| 121 |
| 122 self.mox = mox.Mox() |
| 123 self.testbed = testbed.Testbed() |
| 124 self.testbed.activate() |
| 125 self.testbed.init_user_stub() |
| 126 self.testbed.init_memcache_stub() |
| 127 |
| 128 def tearDown(self): |
| 129 self.testbed.deactivate() |
| 130 self.mox.UnsetStubs() |
| 131 self.mox.ResetAll() |
| 132 |
| 133 def testSearchProjectCan_Normal(self): |
| 134 query_ast = query2ast.ParseUserQuery( |
| 135 'Priority:High', 'is:open', query2ast.BUILTIN_ISSUE_FIELDS, |
| 136 self.config) |
| 137 simplified_query_ast = ast2ast.PreprocessAST( |
| 138 self.cnxn, query_ast, [789], self.services, self.config) |
| 139 conj = simplified_query_ast.conjunctions[0] |
| 140 self.mox.StubOutWithMock(tracker_fulltext, 'SearchIssueFullText') |
| 141 tracker_fulltext.SearchIssueFullText( |
| 142 [789], conj, 2).AndReturn((None, False)) |
| 143 self.mox.StubOutWithMock(self.services.issue, 'RunIssueQuery') |
| 144 self.services.issue.RunIssueQuery( |
| 145 self.cnxn, mox.IsA(list), mox.IsA(list), mox.IsA(list), |
| 146 shard_id=2).AndReturn(([10002, 10052], False)) |
| 147 self.mox.ReplayAll() |
| 148 result, capped = backendsearchpipeline.SearchProjectCan( |
| 149 self.cnxn, self.services, [789], query_ast, 2, self.config) |
| 150 self.mox.VerifyAll() |
| 151 self.assertEqual([10002, 10052], result) |
| 152 self.assertFalse(capped) |
| 153 |
| 154 def testSearchProjectCan_DBCapped(self): |
| 155 query_ast = query2ast.ParseUserQuery( |
| 156 'Priority:High', 'is:open', query2ast.BUILTIN_ISSUE_FIELDS, |
| 157 self.config) |
| 158 simplified_query_ast = ast2ast.PreprocessAST( |
| 159 self.cnxn, query_ast, [789], self.services, self.config) |
| 160 conj = simplified_query_ast.conjunctions[0] |
| 161 self.mox.StubOutWithMock(tracker_fulltext, 'SearchIssueFullText') |
| 162 tracker_fulltext.SearchIssueFullText( |
| 163 [789], conj, 2).AndReturn((None, False)) |
| 164 self.mox.StubOutWithMock(self.services.issue, 'RunIssueQuery') |
| 165 self.services.issue.RunIssueQuery( |
| 166 self.cnxn, mox.IsA(list), mox.IsA(list), mox.IsA(list), |
| 167 shard_id=2).AndReturn(([10002, 10052], True)) |
| 168 self.mox.ReplayAll() |
| 169 result, capped = backendsearchpipeline.SearchProjectCan( |
| 170 self.cnxn, self.services, [789], query_ast, 2, self.config) |
| 171 self.mox.VerifyAll() |
| 172 self.assertEqual([10002, 10052], result) |
| 173 self.assertTrue(capped) |
| 174 |
| 175 def testSearchProjectCan_FTSCapped(self): |
| 176 query_ast = query2ast.ParseUserQuery( |
| 177 'Priority:High', 'is:open', query2ast.BUILTIN_ISSUE_FIELDS, |
| 178 self.config) |
| 179 simplified_query_ast = ast2ast.PreprocessAST( |
| 180 self.cnxn, query_ast, [789], self.services, self.config) |
| 181 conj = simplified_query_ast.conjunctions[0] |
| 182 self.mox.StubOutWithMock(tracker_fulltext, 'SearchIssueFullText') |
| 183 tracker_fulltext.SearchIssueFullText( |
| 184 [789], conj, 2).AndReturn(([10002, 10052], True)) |
| 185 self.mox.StubOutWithMock(self.services.issue, 'RunIssueQuery') |
| 186 self.services.issue.RunIssueQuery( |
| 187 self.cnxn, mox.IsA(list), mox.IsA(list), mox.IsA(list), |
| 188 shard_id=2).AndReturn(([10002, 10052], False)) |
| 189 self.mox.ReplayAll() |
| 190 result, capped = backendsearchpipeline.SearchProjectCan( |
| 191 self.cnxn, self.services, [789], query_ast, 2, self.config) |
| 192 self.mox.VerifyAll() |
| 193 self.assertEqual([10002, 10052], result) |
| 194 self.assertTrue(capped) |
| 195 |
| 196 def testGetQueryResultIIDs(self): |
| 197 sd = ['project', 'id'] |
| 198 slice_term = ('Issue.shard = %s', [2]) |
| 199 query_ast = query2ast.ParseUserQuery( |
| 200 'Priority:High', 'is:open', query2ast.BUILTIN_ISSUE_FIELDS, |
| 201 self.config) |
| 202 query_ast = backendsearchpipeline._FilterSpam(query_ast) |
| 203 |
| 204 self.mox.StubOutWithMock(backendsearchpipeline, 'SearchProjectCan') |
| 205 backendsearchpipeline.SearchProjectCan( |
| 206 self.cnxn, self.services, [789], query_ast, 2, self.config, |
| 207 sort_directives=sd, where=[slice_term], |
| 208 query_desc='getting query issue IDs' |
| 209 ).AndReturn(([10002, 10052], False)) |
| 210 self.mox.ReplayAll() |
| 211 result_iids, limit_reached = backendsearchpipeline._GetQueryResultIIDs( |
| 212 self.cnxn, self.services, 'is:open', 'Priority:High', |
| 213 [789], self.config, sd, slice_term, 2, 12345) |
| 214 self.mox.VerifyAll() |
| 215 self.assertEqual([10002, 10052], result_iids) |
| 216 self.assertFalse(limit_reached) |
| 217 self.assertEqual( |
| 218 ([10002, 10052], 12345), |
| 219 memcache.get('789;is:open;Priority:High;project id;2')) |
| 220 |
| 221 def testGetSpamQueryResultIIDs(self): |
| 222 sd = ['project', 'id'] |
| 223 slice_term = ('Issue.shard = %s', [2]) |
| 224 query_ast = query2ast.ParseUserQuery( |
| 225 'Priority:High is:spam', 'is:open', query2ast.BUILTIN_ISSUE_FIELDS, |
| 226 self.config) |
| 227 |
| 228 query_ast = backendsearchpipeline._FilterSpam(query_ast) |
| 229 |
| 230 self.mox.StubOutWithMock(backendsearchpipeline, 'SearchProjectCan') |
| 231 backendsearchpipeline.SearchProjectCan( |
| 232 self.cnxn, self.services, [789], query_ast, 2, self.config, |
| 233 sort_directives=sd, where=[slice_term], |
| 234 query_desc='getting query issue IDs' |
| 235 ).AndReturn(([10002, 10052], False)) |
| 236 self.mox.ReplayAll() |
| 237 result_iids, limit_reached = backendsearchpipeline._GetQueryResultIIDs( |
| 238 self.cnxn, self.services, 'is:open', 'Priority:High is:spam', |
| 239 [789], self.config, sd, slice_term, 2, 12345) |
| 240 self.mox.VerifyAll() |
| 241 self.assertEqual([10002, 10052], result_iids) |
| 242 self.assertFalse(limit_reached) |
| 243 self.assertEqual( |
| 244 ([10002, 10052], 12345), |
| 245 memcache.get('789;is:open;Priority:High is:spam;project id;2')) |
| 246 |
| 247 |
| 248 if __name__ == '__main__': |
| 249 unittest.main() |
OLD | NEW |