|
32 | 32 |
|
33 | 33 | from mig.shared.fileio import pickle, read_file |
34 | 34 | from mig.shared.vgrid import vgrid_list, vgrid_set_entities, vgrid_settings |
35 | | -from mig.shared.vgridaccess import OWNERS, RESOURCES, SETTINGS, VGRIDS, \ |
36 | | - check_vgrid_access, force_update_resource_map, force_update_user_map, \ |
37 | | - force_update_vgrid_map, get_resource_map, get_vgrid_map, \ |
38 | | - load_resource_map, refresh_vgrid_map, vgrid_inherit_map |
| 35 | +from mig.shared.vgridaccess import CONF, MEMBERS, OWNERS, RESOURCES, SETTINGS, \ |
| 36 | + USERID, VGRIDS, check_vgrid_access, force_update_resource_map, \ |
| 37 | + force_update_user_map, force_update_vgrid_map, get_resource_map, \ |
| 38 | + get_user_map, get_vgrid_map, load_resource_map, refresh_vgrid_map, \ |
| 39 | + user_vgrid_access, vgrid_inherit_map |
39 | 40 | from tests.support import MigTestCase, ensure_dirs_exist, testmain |
40 | 41 |
|
41 | 42 |
|
42 | 43 | class TestMigSharedVgridAccess(MigTestCase): |
43 | 44 | """Unit tests for vgridaccess related helper functions""" |
44 | 45 |
|
| 46 | + TEST_USER_DN = \ |
| 47 | + '/C=DK/ST=NA/L=NA/O=Test Org/OU=NA/CN=Test User/'\ |
| 48 | + 'emailAddress=test@example.com' |
45 | 49 | TEST_OWNER_DN = \ |
46 | 50 | '/C=DK/ST=NA/L=NA/O=Test Org/OU=NA/CN=Test Owner/'\ |
47 | 51 | 'emailAddress=owner@example.org' |
48 | 52 | TEST_MEMBER_DN = \ |
49 | 53 | '/C=DK/ST=NA/L=NA/O=Test Org/OU=NA/CN=Test Member/'\ |
50 | 54 | 'emailAddress=member@example.org' |
| 55 | + TEST_OUTSIDER_DN = \ |
| 56 | + '/C=DK/ST=NA/L=NA/O=Test Org/OU=NA/CN=Test Outsider/'\ |
| 57 | + 'emailAddress=outsider@example.com' |
51 | 58 | TEST_RESOURCE_ID = 'test.example.org.0' |
| 59 | + TEST_OWNER_UUID = 'ff326a2b984828d9b32077c9b0b35a05' |
| 60 | + TEST_USER_UUID = '707a2213995b4fb385793b5a7cb82a18' |
52 | 61 |
|
53 | 62 | def _provide_configuration(self): |
54 | 63 | """Prepare isolated test config""" |
@@ -211,6 +220,155 @@ def test_settings_inheritance(self): |
211 | 220 | # Verify hidden setting inheritance |
212 | 221 | self.assertEqual(sub_settings_dict.get('hidden'), True) |
213 | 222 |
|
| 223 | + def test_user_map_fields(self): |
| 224 | + """Verify user map includes complete profile/settings data""" |
| 225 | + # First add a couple of test users |
| 226 | + self._provision_test_user(self, self.TEST_OWNER_DN) |
| 227 | + self._provision_test_user(self, self.TEST_USER_DN) |
| 228 | + # Force fresh user map |
| 229 | + initial_vgrid_map = force_update_vgrid_map(self.configuration, |
| 230 | + clean=True) |
| 231 | + user_map = force_update_user_map(self.configuration) |
| 232 | + test_owner = user_map.get(self.TEST_OWNER_DN, {}) |
| 233 | + self.assertEqual(test_owner.get(USERID), self.TEST_OWNER_UUID) |
| 234 | + self.assertTrue(isinstance(test_owner.get(CONF), dict)) |
| 235 | + test_user = user_map.get(self.TEST_USER_DN, {}) |
| 236 | + self.assertEqual(test_user.get(USERID), self.TEST_USER_UUID) |
| 237 | + self.assertTrue(isinstance(test_user.get(CONF), dict)) |
| 238 | + |
| 239 | + def test_resource_revoked_access(self): |
| 240 | + """Verify resource removal propagates through cached maps""" |
| 241 | + # First add resource and vgrid |
| 242 | + self._create_resource(self.TEST_RESOURCE_ID, [self.TEST_OWNER_DN]) |
| 243 | + self._create_vgrid(self.test_vgrid, owners=[self.TEST_OWNER_DN], |
| 244 | + resources=[self.TEST_RESOURCE_ID]) |
| 245 | + |
| 246 | + initial_vgrid_map = force_update_vgrid_map(self.configuration, |
| 247 | + clean=True) |
| 248 | + # Check vgrid map contains resource entry |
| 249 | + vgrid_data = initial_vgrid_map.get(VGRIDS, {}) |
| 250 | + top_vgrid_data = vgrid_data.get(self.test_vgrid, {}) |
| 251 | + top_vgrid_res = top_vgrid_data.get(RESOURCES, []) |
| 252 | + self.assertTrue(self.TEST_RESOURCE_ID in top_vgrid_res) |
| 253 | + |
| 254 | + # Check resource map contains resource entry |
| 255 | + initial_map = force_update_resource_map(self.configuration, |
| 256 | + clean=True) |
| 257 | + self.assertIn(self.TEST_RESOURCE_ID, initial_map) |
| 258 | + |
| 259 | + # Remove resource assignment from vgrid |
| 260 | + status, msg = vgrid_set_entities(self.configuration, self.test_vgrid, |
| 261 | + 'resources', [], allow_empty=True) |
| 262 | + self.assertTrue(status, msg) |
| 263 | + |
| 264 | + updated_vgrid_map = force_update_vgrid_map(self.configuration, |
| 265 | + clean=True) |
| 266 | + # Check vgrid map no longer contains resource entry |
| 267 | + vgrid_data = updated_vgrid_map.get(VGRIDS, {}) |
| 268 | + top_vgrid_data = vgrid_data.get(self.test_vgrid, {}) |
| 269 | + top_vgrid_res = top_vgrid_data.get(RESOURCES, []) |
| 270 | + self.assertFalse(self.TEST_RESOURCE_ID in top_vgrid_res) |
| 271 | + |
| 272 | + # Verify resource still in resource map |
| 273 | + updated_map = force_update_resource_map(self.configuration, |
| 274 | + clean=True) |
| 275 | + self.assertIn(self.TEST_RESOURCE_ID, updated_map) |
| 276 | + |
| 277 | + def test_non_recursive_inheritance(self): |
| 278 | + """Verify non-recursive map excludes nested vgrids""" |
| 279 | + # Create parent+child vgrids |
| 280 | + parent_vgrid = 'parent' |
| 281 | + self._create_vgrid(parent_vgrid, [self.TEST_OWNER_DN]) |
| 282 | + child_vgrid = os.path.join(parent_vgrid, 'child') |
| 283 | + self._create_vgrid(child_vgrid, None, [self.TEST_MEMBER_DN]) |
| 284 | + |
| 285 | + # Force update to avoid auto caching and get non-recursive map |
| 286 | + vgrid_map = force_update_vgrid_map(self.configuration, |
| 287 | + clean=True) |
| 288 | + vgrid_map = get_vgrid_map(self.configuration, recursive=False) |
| 289 | + # Parent should appear |
| 290 | + self.assertIn(parent_vgrid, vgrid_map.get(VGRIDS, {})) |
| 291 | + # Child should still appear when non-recursive but just not inherit |
| 292 | + self.assertIn(child_vgrid, vgrid_map.get(VGRIDS, {})) |
| 293 | + # Check owners and members to verify they aren't inherited |
| 294 | + self.assertEqual(vgrid_map[VGRIDS][parent_vgrid][OWNERS], |
| 295 | + [self.TEST_OWNER_DN]) |
| 296 | + self.assertEqual(len(vgrid_map[VGRIDS][parent_vgrid][MEMBERS]), 0) |
| 297 | + self.assertEqual(len(vgrid_map[VGRIDS][child_vgrid][OWNERS]), 0) |
| 298 | + self.assertEqual(vgrid_map[VGRIDS][child_vgrid][MEMBERS], |
| 299 | + [self.TEST_MEMBER_DN]) |
| 300 | + |
| 301 | + def test_hidden_setting_propagation(self): |
| 302 | + """Verify hidden=True propagates to not infect parent settings""" |
| 303 | + parent_vgrid = 'parent' |
| 304 | + self._create_vgrid(parent_vgrid, [self.TEST_OWNER_DN]) |
| 305 | + child_vgrid = os.path.join(parent_vgrid, 'child') |
| 306 | + self._create_vgrid(child_vgrid, [self.TEST_OWNER_DN], |
| 307 | + settings=[('vgrid_name', child_vgrid), |
| 308 | + ('hidden', True)]) |
| 309 | + |
| 310 | + # Verify parent remains visible in cache |
| 311 | + updated_map = force_update_vgrid_map(self.configuration) |
| 312 | + parent_data = updated_map.get(VGRIDS, {}).get(parent_vgrid, {}) |
| 313 | + parent_settings = dict(parent_data.get(SETTINGS, [])) |
| 314 | + self.assertNotEqual(parent_settings.get('hidden'), True) |
| 315 | + |
| 316 | + def test_default_vgrid_access(self): |
| 317 | + """Verify special access rules for default vgrid""" |
| 318 | + self._create_vgrid(self.test_vgrid, owners=[self.TEST_OWNER_DN], |
| 319 | + members=[self.TEST_MEMBER_DN]) |
| 320 | + |
| 321 | + initial_vgrid_map = force_update_vgrid_map(self.configuration, |
| 322 | + clean=True) |
| 323 | + |
| 324 | + # Even non-member should have access to default vgrid |
| 325 | + participant = check_vgrid_access(self.configuration, |
| 326 | + self.TEST_OUTSIDER_DN, |
| 327 | + 'Generic') |
| 328 | + self.assertFalse(participant) |
| 329 | + allowed_vgrids = user_vgrid_access(self.configuration, |
| 330 | + self.TEST_OUTSIDER_DN) |
| 331 | + self.assertTrue('Generic' in allowed_vgrids) |
| 332 | + |
| 333 | + # Invalid vgrid should not allow any participation or access |
| 334 | + participant = check_vgrid_access(self.configuration, self.TEST_MEMBER_DN, |
| 335 | + 'invalid-vgrid-name') |
| 336 | + self.assertFalse(participant) |
| 337 | + allowed_vgrids = user_vgrid_access(self.configuration, |
| 338 | + self.TEST_MEMBER_DN) |
| 339 | + self.assertFalse('invalid-vgrid-name' in allowed_vgrids) |
| 340 | + |
| 341 | + def test_general_vgrid_access(self): |
| 342 | + """Verify general access rules for vgrids""" |
| 343 | + self._create_vgrid(self.test_vgrid, owners=[self.TEST_OWNER_DN], |
| 344 | + members=[self.TEST_MEMBER_DN]) |
| 345 | + |
| 346 | + initial_vgrid_map = force_update_vgrid_map(self.configuration, |
| 347 | + clean=True) |
| 348 | + |
| 349 | + # Test vgrid must allow owner and members access |
| 350 | + allowed = check_vgrid_access(self.configuration, self.TEST_OWNER_DN, |
| 351 | + self.test_vgrid) |
| 352 | + self.assertTrue(allowed) |
| 353 | + allowed_vgrids = user_vgrid_access(self.configuration, |
| 354 | + self.TEST_OWNER_DN) |
| 355 | + self.assertTrue(self.test_vgrid in allowed_vgrids) |
| 356 | + |
| 357 | + allowed = check_vgrid_access(self.configuration, self.TEST_MEMBER_DN, |
| 358 | + self.test_vgrid) |
| 359 | + self.assertTrue(allowed) |
| 360 | + allowed_vgrids = user_vgrid_access(self.configuration, |
| 361 | + self.TEST_MEMBER_DN) |
| 362 | + self.assertTrue(self.test_vgrid in allowed_vgrids) |
| 363 | + |
| 364 | + # Test vgrid must reject allow outsider access |
| 365 | + allowed = check_vgrid_access(self.configuration, self.TEST_OUTSIDER_DN, |
| 366 | + self.test_vgrid) |
| 367 | + self.assertFalse(allowed) |
| 368 | + allowed_vgrids = user_vgrid_access(self.configuration, |
| 369 | + self.TEST_OUTSIDER_DN) |
| 370 | + self.assertFalse(self.test_vgrid in allowed_vgrids) |
| 371 | + |
214 | 372 |
|
215 | 373 | if __name__ == '__main__': |
216 | 374 | testmain() |
0 commit comments