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 project_svc module.""" |
| 7 |
| 8 import time |
| 9 import unittest |
| 10 |
| 11 import mox |
| 12 |
| 13 from google.appengine.ext import testbed |
| 14 |
| 15 from framework import sql |
| 16 from proto import project_pb2 |
| 17 from proto import user_pb2 |
| 18 from services import config_svc |
| 19 from services import project_svc |
| 20 from testing import fake |
| 21 |
| 22 NOW = 12345678 |
| 23 |
| 24 |
| 25 def MakeProjectService(cache_manager, my_mox): |
| 26 project_service = project_svc.ProjectService(cache_manager) |
| 27 project_service.project_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| 28 project_service.user2project_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| 29 project_service.extraperm_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| 30 project_service.membernotes_tbl = my_mox.CreateMock(sql.SQLTableManager) |
| 31 project_service.usergroupprojects_tbl = my_mox.CreateMock( |
| 32 sql.SQLTableManager) |
| 33 return project_service |
| 34 |
| 35 |
| 36 class ProjectTwoLevelCacheTest(unittest.TestCase): |
| 37 |
| 38 def setUp(self): |
| 39 self.testbed = testbed.Testbed() |
| 40 self.testbed.activate() |
| 41 self.testbed.init_memcache_stub() |
| 42 |
| 43 self.mox = mox.Mox() |
| 44 self.cnxn = self.mox.CreateMock(sql.MonorailConnection) |
| 45 self.cache_manager = fake.CacheManager() |
| 46 self.project_service = MakeProjectService(self.cache_manager, self.mox) |
| 47 |
| 48 def testDeserializeProjects(self): |
| 49 project_rows = [ |
| 50 (123, 'proj1', 'test proj 1', 'test project', 'live', 'anyone', '', '', |
| 51 None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 52 False, None, None, None, None, None), |
| 53 (234, 'proj2', 'test proj 2', 'test project', 'live', 'anyone', '', '', |
| 54 None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 55 False, None, None, None, None, None)] |
| 56 role_rows = [ |
| 57 (123, 111L, 'owner'), (123, 444L, 'owner'), |
| 58 (123, 222L, 'committer'), |
| 59 (123, 333L, 'contributor'), |
| 60 (234, 111L, 'owner')] |
| 61 extraperm_rows = [] |
| 62 |
| 63 project_dict = self.project_service.project_2lc._DeserializeProjects( |
| 64 project_rows, role_rows, extraperm_rows) |
| 65 |
| 66 self.assertItemsEqual([123, 234], project_dict.keys()) |
| 67 self.assertEqual(123, project_dict[123].project_id) |
| 68 self.assertEqual('proj1', project_dict[123].project_name) |
| 69 self.assertEqual(NOW, project_dict[123].recent_activity) |
| 70 self.assertItemsEqual([111L, 444L], project_dict[123].owner_ids) |
| 71 self.assertItemsEqual([222L], project_dict[123].committer_ids) |
| 72 self.assertItemsEqual([333L], project_dict[123].contributor_ids) |
| 73 self.assertEqual(234, project_dict[234].project_id) |
| 74 self.assertItemsEqual([111L], project_dict[234].owner_ids) |
| 75 |
| 76 |
| 77 class ProjectServiceTest(unittest.TestCase): |
| 78 |
| 79 def setUp(self): |
| 80 self.testbed = testbed.Testbed() |
| 81 self.testbed.activate() |
| 82 self.testbed.init_memcache_stub() |
| 83 |
| 84 self.mox = mox.Mox() |
| 85 self.cnxn = self.mox.CreateMock(sql.MonorailConnection) |
| 86 self.cache_manager = fake.CacheManager() |
| 87 self.config_service = self.mox.CreateMock(config_svc.ConfigService) |
| 88 self.project_service = MakeProjectService(self.cache_manager, self.mox) |
| 89 |
| 90 self.proj1 = fake.Project(project_name='proj1', project_id=123) |
| 91 self.proj2 = fake.Project(project_name='proj2', project_id=234) |
| 92 |
| 93 def tearDown(self): |
| 94 self.testbed.deactivate() |
| 95 self.mox.UnsetStubs() |
| 96 self.mox.ResetAll() |
| 97 |
| 98 def SetUpCreateProject(self): |
| 99 # Check for existing project: there should be none. |
| 100 self.project_service.project_tbl.Select( |
| 101 self.cnxn, cols=['project_name', 'project_id'], |
| 102 project_name=['proj1']).AndReturn([]) |
| 103 |
| 104 # Inserting the project gives the project ID. |
| 105 self.project_service.project_tbl.InsertRow( |
| 106 self.cnxn, project_name='proj1', |
| 107 summary='Test project summary', description='Test project description', |
| 108 home_page=None, docs_url=None, logo_file_name=None, logo_gcs_id=None, |
| 109 state='LIVE', access='ANYONE').AndReturn(123) |
| 110 |
| 111 # Insert the users. There are none. |
| 112 self.project_service.user2project_tbl.InsertRows( |
| 113 self.cnxn, ['project_id', 'user_id', 'role_name'], []) |
| 114 |
| 115 def testCreateProject(self): |
| 116 self.SetUpCreateProject() |
| 117 self.mox.ReplayAll() |
| 118 self.project_service.CreateProject( |
| 119 self.cnxn, 'proj1', owner_ids=[], committer_ids=[], contributor_ids=[], |
| 120 summary='Test project summary', description='Test project description') |
| 121 self.mox.VerifyAll() |
| 122 |
| 123 def SetUpLookupProjectIDs(self): |
| 124 self.project_service.project_tbl.Select( |
| 125 self.cnxn, cols=['project_name', 'project_id'], |
| 126 project_name=['proj2']).AndReturn([('proj2', 234)]) |
| 127 |
| 128 def testLookupProjectIDs(self): |
| 129 self.SetUpLookupProjectIDs() |
| 130 self.project_service.project_names_to_ids.CacheItem('proj1', 123) |
| 131 self.mox.ReplayAll() |
| 132 id_dict = self.project_service.LookupProjectIDs( |
| 133 self.cnxn, ['proj1', 'proj2']) |
| 134 self.mox.VerifyAll() |
| 135 self.assertEqual({'proj1': 123, 'proj2': 234}, id_dict) |
| 136 |
| 137 def testLookupProjectNames(self): |
| 138 self.SetUpGetProjects() # Same as testGetProjects() |
| 139 self.project_service.project_2lc.CacheItem(123, self.proj1) |
| 140 self.mox.ReplayAll() |
| 141 name_dict = self.project_service.LookupProjectNames( |
| 142 self.cnxn, [123, 234]) |
| 143 self.mox.VerifyAll() |
| 144 self.assertEqual({123: 'proj1', 234: 'proj2'}, name_dict) |
| 145 |
| 146 def SetUpGetProjects(self): |
| 147 project_rows = [ |
| 148 (234, 'proj2', 'test proj 2', 'test project', 'live', 'anyone', '', '', |
| 149 None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 150 False, None, None, None, None, None)] |
| 151 self.project_service.project_tbl.Select( |
| 152 self.cnxn, cols=project_svc.PROJECT_COLS, |
| 153 project_id=[234]).AndReturn(project_rows) |
| 154 self.project_service.user2project_tbl.Select( |
| 155 self.cnxn, cols=['project_id', 'user_id', 'role_name'], |
| 156 project_id=[234]).AndReturn([]) |
| 157 self.project_service.extraperm_tbl.Select( |
| 158 self.cnxn, cols=project_svc.EXTRAPERM_COLS, |
| 159 project_id=[234]).AndReturn([]) |
| 160 |
| 161 def testGetProjects(self): |
| 162 self.project_service.project_2lc.CacheItem(123, self.proj1) |
| 163 self.SetUpGetProjects() |
| 164 self.mox.ReplayAll() |
| 165 project_dict = self.project_service.GetProjects( |
| 166 self.cnxn, [123, 234]) |
| 167 self.mox.VerifyAll() |
| 168 self.assertItemsEqual([123, 234], project_dict.keys()) |
| 169 self.assertEqual('proj1', project_dict[123].project_name) |
| 170 self.assertEqual('proj2', project_dict[234].project_name) |
| 171 |
| 172 def testGetVisibleLiveProjects_AnyoneAccessWithUser(self): |
| 173 project_rows = [ |
| 174 (234, 'proj2', 'test proj 2', 'test project', 'live', 'anyone', '', '', |
| 175 None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 176 False, None, None)] |
| 177 |
| 178 self.project_service.project_tbl.Select( |
| 179 self.cnxn, cols=['project_id'], |
| 180 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 181 self.SetUpGetProjects() |
| 182 self.mox.ReplayAll() |
| 183 user_a = user_pb2.User(email='a@example.com') |
| 184 project_ids = self.project_service.GetVisibleLiveProjects( |
| 185 self.cnxn, user_a, set([111])) |
| 186 |
| 187 self.mox.VerifyAll() |
| 188 self.assertItemsEqual([234], project_ids) |
| 189 |
| 190 def testGetVisibleLiveProjects_AnyoneAccessWithAnon(self): |
| 191 project_rows = [ |
| 192 (234, 'proj2', 'test proj 2', 'test project', 'live', 'anyone', '', '', |
| 193 None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 194 False, None, None, None, None, None)] |
| 195 |
| 196 self.project_service.project_tbl.Select( |
| 197 self.cnxn, cols=['project_id'], |
| 198 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 199 self.SetUpGetProjects() |
| 200 self.mox.ReplayAll() |
| 201 project_ids = self.project_service.GetVisibleLiveProjects( |
| 202 self.cnxn, None, None) |
| 203 |
| 204 self.mox.VerifyAll() |
| 205 self.assertItemsEqual([234], project_ids) |
| 206 |
| 207 def testGetVisibleLiveProjects_RestrictedAccessWithMember(self): |
| 208 project_rows = [ |
| 209 (234, 'proj2', 'test proj 2', 'test project', 'live', 'members_only', |
| 210 '', '', None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, False, |
| 211 False, False, None, None, None, None, None)] |
| 212 self.proj2.access = project_pb2.ProjectAccess.MEMBERS_ONLY |
| 213 self.proj2.contributor_ids.append(111) |
| 214 self.project_service.project_2lc.CacheItem(234, self.proj2) |
| 215 |
| 216 self.project_service.project_tbl.Select( |
| 217 self.cnxn, cols=['project_id'], |
| 218 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 219 self.mox.ReplayAll() |
| 220 user_a = user_pb2.User(email='a@example.com') |
| 221 project_ids = self.project_service.GetVisibleLiveProjects( |
| 222 self.cnxn, user_a, set([111])) |
| 223 |
| 224 self.mox.VerifyAll() |
| 225 self.assertItemsEqual([234], project_ids) |
| 226 |
| 227 def testGetVisibleLiveProjects_RestrictedAccessWithNonMember(self): |
| 228 project_rows = [ |
| 229 (234, 'proj2', 'test proj 2', 'test project', 'live', 'members_only', |
| 230 '', '', None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, |
| 231 False, False, None, None, None, None, None)] |
| 232 self.proj2.access = project_pb2.ProjectAccess.MEMBERS_ONLY |
| 233 self.project_service.project_2lc.CacheItem(234, self.proj2) |
| 234 |
| 235 self.project_service.project_tbl.Select( |
| 236 self.cnxn, cols=['project_id'], |
| 237 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 238 self.mox.ReplayAll() |
| 239 user_a = user_pb2.User(email='a@example.com') |
| 240 project_ids = self.project_service.GetVisibleLiveProjects( |
| 241 self.cnxn, user_a, set([111])) |
| 242 |
| 243 self.mox.VerifyAll() |
| 244 self.assertItemsEqual([], project_ids) |
| 245 |
| 246 def testGetVisibleLiveProjects_RestrictedAccessWithAnon(self): |
| 247 project_rows = [ |
| 248 (234, 'proj2', 'test proj 2', 'test project', 'live', 'members_only', |
| 249 '', '', None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, |
| 250 False, False, None, None, None, None, None)] |
| 251 self.proj2.access = project_pb2.ProjectAccess.MEMBERS_ONLY |
| 252 self.project_service.project_2lc.CacheItem(234, self.proj2) |
| 253 |
| 254 self.project_service.project_tbl.Select( |
| 255 self.cnxn, cols=['project_id'], |
| 256 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 257 self.mox.ReplayAll() |
| 258 project_ids = self.project_service.GetVisibleLiveProjects( |
| 259 self.cnxn, None, None) |
| 260 |
| 261 self.mox.VerifyAll() |
| 262 self.assertItemsEqual([], project_ids) |
| 263 |
| 264 def testGetVisibleLiveProjects_RestrictedAccessWithSiteAdmin(self): |
| 265 project_rows = [ |
| 266 (234, 'proj2', 'test proj 2', 'test project', 'live', 'members_only', |
| 267 '', '', None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, |
| 268 False, False, None, None, None, None, None)] |
| 269 self.proj2.access = project_pb2.ProjectAccess.MEMBERS_ONLY |
| 270 self.project_service.project_2lc.CacheItem(234, self.proj2) |
| 271 |
| 272 self.project_service.project_tbl.Select( |
| 273 self.cnxn, cols=['project_id'], |
| 274 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 275 self.mox.ReplayAll() |
| 276 user_a = user_pb2.User(email='a@example.com') |
| 277 user_a.is_site_admin = True |
| 278 project_ids = self.project_service.GetVisibleLiveProjects( |
| 279 self.cnxn, user_a, set([111])) |
| 280 |
| 281 self.mox.VerifyAll() |
| 282 self.assertItemsEqual([234], project_ids) |
| 283 |
| 284 def testGetVisibleLiveProjects_ArchivedProject(self): |
| 285 project_rows = [ |
| 286 (234, 'proj2', 'test proj 2', 'test project', 'archived', 'anyone', |
| 287 '', '', None, '', 0, 50 * 1024 * 1024, NOW, NOW, None, True, |
| 288 False, False, None, None, None, None, None)] |
| 289 self.proj2.state = project_pb2.ProjectState.ARCHIVED |
| 290 self.project_service.project_2lc.CacheItem(234, self.proj2) |
| 291 |
| 292 self.project_service.project_tbl.Select( |
| 293 self.cnxn, cols=['project_id'], |
| 294 state=project_pb2.ProjectState.LIVE).AndReturn(project_rows) |
| 295 self.mox.ReplayAll() |
| 296 user_a = user_pb2.User(email='a@example.com') |
| 297 project_ids = self.project_service.GetVisibleLiveProjects( |
| 298 self.cnxn, user_a, set([111])) |
| 299 |
| 300 self.mox.VerifyAll() |
| 301 self.assertItemsEqual([], project_ids) |
| 302 |
| 303 def testGetProjectsByName(self): |
| 304 self.project_service.project_names_to_ids.CacheItem('proj1', 123) |
| 305 self.project_service.project_2lc.CacheItem(123, self.proj1) |
| 306 self.SetUpLookupProjectIDs() |
| 307 self.SetUpGetProjects() |
| 308 self.mox.ReplayAll() |
| 309 project_dict = self.project_service.GetProjectsByName( |
| 310 self.cnxn, ['proj1', 'proj2']) |
| 311 self.mox.VerifyAll() |
| 312 self.assertItemsEqual(['proj1', 'proj2'], project_dict.keys()) |
| 313 self.assertEqual(123, project_dict['proj1'].project_id) |
| 314 self.assertEqual(234, project_dict['proj2'].project_id) |
| 315 |
| 316 def SetUpExpungeProject(self): |
| 317 self.project_service.user2project_tbl.Delete( |
| 318 self.cnxn, project_id=234) |
| 319 self.project_service.usergroupprojects_tbl.Delete( |
| 320 self.cnxn, project_id=234) |
| 321 self.project_service.extraperm_tbl.Delete( |
| 322 self.cnxn, project_id=234) |
| 323 self.project_service.membernotes_tbl.Delete( |
| 324 self.cnxn, project_id=234) |
| 325 self.project_service.project_tbl.Delete( |
| 326 self.cnxn, project_id=234) |
| 327 |
| 328 def testExpungeProject(self): |
| 329 self.SetUpExpungeProject() |
| 330 self.mox.ReplayAll() |
| 331 self.project_service.ExpungeProject(self.cnxn, 234) |
| 332 self.mox.VerifyAll() |
| 333 |
| 334 def SetUpUpdateProject(self, project_id, delta): |
| 335 self.project_service.project_tbl.Update( |
| 336 self.cnxn, delta, project_id=project_id) |
| 337 |
| 338 def testUpdateProject(self): |
| 339 self.SetUpGetProjects() |
| 340 delta = {'summary': 'An even better one-line summary'} |
| 341 self.SetUpUpdateProject(234, delta) |
| 342 self.mox.ReplayAll() |
| 343 self.project_service.UpdateProject( |
| 344 self.cnxn, 234, summary='An even better one-line summary') |
| 345 self.mox.VerifyAll() |
| 346 |
| 347 def SetUpUpdateProjectRoles( |
| 348 self, project_id, owner_ids, committer_ids, contributor_ids): |
| 349 self.project_service.project_tbl.Update( |
| 350 self.cnxn, {'cached_content_timestamp': NOW}, project_id=project_id) |
| 351 |
| 352 self.project_service.user2project_tbl.Delete( |
| 353 self.cnxn, project_id=project_id, role_name='owner', commit=False) |
| 354 self.project_service.user2project_tbl.Delete( |
| 355 self.cnxn, project_id=project_id, role_name='committer', commit=False) |
| 356 self.project_service.user2project_tbl.Delete( |
| 357 self.cnxn, project_id=project_id, role_name='contributor', |
| 358 commit=False) |
| 359 |
| 360 self.project_service.user2project_tbl.InsertRows( |
| 361 self.cnxn, ['project_id', 'user_id', 'role_name'], |
| 362 [(project_id, user_id, 'owner') for user_id in owner_ids], |
| 363 commit=False) |
| 364 self.project_service.user2project_tbl.InsertRows( |
| 365 self.cnxn, ['project_id', 'user_id', 'role_name'], |
| 366 [(project_id, user_id, 'committer') for user_id in committer_ids], |
| 367 commit=False) |
| 368 self.project_service.user2project_tbl.InsertRows( |
| 369 self.cnxn, ['project_id', 'user_id', 'role_name'], |
| 370 [(project_id, user_id, 'contributor') for user_id in contributor_ids], |
| 371 commit=False) |
| 372 |
| 373 self.cnxn.Commit() |
| 374 |
| 375 def testUpdateProjectRoles(self): |
| 376 self.SetUpGetProjects() |
| 377 self.SetUpUpdateProjectRoles(234, [111L, 222L], [333L], []) |
| 378 self.mox.ReplayAll() |
| 379 self.project_service.UpdateProjectRoles( |
| 380 self.cnxn, 234, [111L, 222L], [333L], [], now=NOW) |
| 381 self.mox.VerifyAll() |
| 382 |
| 383 def SetUpMarkProjectDeletable(self): |
| 384 delta = { |
| 385 'project_name': 'DELETABLE_123', |
| 386 'state': 'deletable', |
| 387 } |
| 388 self.project_service.project_tbl.Update(self.cnxn, delta, project_id=123) |
| 389 self.config_service.InvalidateMemcacheForEntireProject(123) |
| 390 |
| 391 def testMarkProjectDeletable(self): |
| 392 self.SetUpMarkProjectDeletable() |
| 393 self.mox.ReplayAll() |
| 394 self.project_service.MarkProjectDeletable( |
| 395 self.cnxn, 123, self.config_service) |
| 396 self.mox.VerifyAll() |
| 397 |
| 398 def testUpdateRecentActivity(self): |
| 399 self.SetUpGetProjects() |
| 400 delta = {'recent_activity_timestamp': NOW} |
| 401 self.SetUpUpdateProject(234, delta) |
| 402 self.mox.ReplayAll() |
| 403 self.project_service.UpdateRecentActivity(self.cnxn, 234, now=NOW) |
| 404 self.mox.VerifyAll() |
| 405 |
| 406 def SetUpGetUserRolesInAllProjects(self): |
| 407 rows = [ |
| 408 (123, 'committer'), |
| 409 (234, 'owner'), |
| 410 ] |
| 411 self.project_service.user2project_tbl.Select( |
| 412 self.cnxn, cols=['project_id', 'role_name'], |
| 413 user_id={111L, 888L}).AndReturn(rows) |
| 414 |
| 415 def testGetUserRolesInAllProjects(self): |
| 416 self.SetUpGetUserRolesInAllProjects() |
| 417 self.mox.ReplayAll() |
| 418 actual = self.project_service.GetUserRolesInAllProjects( |
| 419 self.cnxn, {111L, 888L}) |
| 420 owned_project_ids, membered_project_ids, contrib_project_ids = actual |
| 421 self.mox.VerifyAll() |
| 422 self.assertItemsEqual([234], owned_project_ids) |
| 423 self.assertItemsEqual([123], membered_project_ids) |
| 424 self.assertItemsEqual([], contrib_project_ids) |
| 425 |
| 426 def SetUpUpdateExtraPerms(self): |
| 427 self.project_service.extraperm_tbl.Delete( |
| 428 self.cnxn, project_id=234, user_id=111L, commit=False) |
| 429 self.project_service.extraperm_tbl.InsertRows( |
| 430 self.cnxn, project_svc.EXTRAPERM_COLS, |
| 431 [(234, 111L, 'SecurityTeam')], commit=False) |
| 432 self.project_service.project_tbl.Update( |
| 433 self.cnxn, {'cached_content_timestamp': NOW}, |
| 434 project_id=234, commit=False) |
| 435 self.cnxn.Commit() |
| 436 |
| 437 def testUpdateExtraPerms(self): |
| 438 self.SetUpGetProjects() |
| 439 self.SetUpUpdateExtraPerms() |
| 440 self.mox.ReplayAll() |
| 441 self.project_service.UpdateExtraPerms( |
| 442 self.cnxn, 234, 111L, ['SecurityTeam'], now=NOW) |
| 443 self.mox.VerifyAll() |
| 444 |
| 445 |
| 446 if __name__ == '__main__': |
| 447 unittest.main() |
OLD | NEW |