def test_id_mapping_crud(self):
initial_mappings = len(mapping_sql.list_id_mappings())
local_id1 = uuid.uuid4().hex
local_id2 = uuid.uuid4().hex
local_entity1 = {'domain_id': self.domainA['id'],
'local_id': local_id1,
'entity_type': mapping.EntityType.USER}
local_entity2 = {'domain_id': self.domainB['id'],
'local_id': local_id2,
'entity_type': mapping.EntityType.GROUP}
# Check no mappings for the new local entities
self.assertIsNone(
PROVIDERS.id_mapping_api.get_public_id(local_entity1)
)
self.assertIsNone(
PROVIDERS.id_mapping_api.get_public_id(local_entity2)
)
# Create the new mappings and then read them back
public_id1 = PROVIDERS.id_mapping_api.create_id_mapping(local_entity1)
public_id2 = PROVIDERS.id_mapping_api.create_id_mapping(local_entity2)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 2))
self.assertEqual(
public_id1, PROVIDERS.id_mapping_api.get_public_id(local_entity1))
self.assertEqual(
public_id2, PROVIDERS.id_mapping_api.get_public_id(local_entity2))
local_id_ref = PROVIDERS.id_mapping_api.get_id_mapping(public_id1)
self.assertEqual(self.domainA['id'], local_id_ref['domain_id'])
self.assertEqual(local_id1, local_id_ref['local_id'])
self.assertEqual(mapping.EntityType.USER, local_id_ref['entity_type'])
# Check we have really created a new external ID
self.assertNotEqual(local_id1, public_id1)
local_id_ref = PROVIDERS.id_mapping_api.get_id_mapping(public_id2)
self.assertEqual(self.domainB['id'], local_id_ref['domain_id'])
self.assertEqual(local_id2, local_id_ref['local_id'])
self.assertEqual(mapping.EntityType.GROUP, local_id_ref['entity_type'])
# Check we have really created a new external ID
self.assertNotEqual(local_id2, public_id2)
# Create another mappings, this time specifying a public ID to use
new_public_id = uuid.uuid4().hex
public_id3 = PROVIDERS.id_mapping_api.create_id_mapping(
{'domain_id': self.domainB['id'], 'local_id': local_id2,
'entity_type': mapping.EntityType.USER},
public_id=new_public_id)
self.assertEqual(new_public_id, public_id3)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 3))
# Delete the mappings we created, and make sure the mapping count
# goes back to where it was
PROVIDERS.id_mapping_api.delete_id_mapping(public_id1)
PROVIDERS.id_mapping_api.delete_id_mapping(public_id2)
PROVIDERS.id_mapping_api.delete_id_mapping(public_id3)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings))
def test_id_mapping_crud(self):
initial_mappings = len(mapping_sql.list_id_mappings())
local_id1 = uuid.uuid4().hex
local_id2 = uuid.uuid4().hex
local_entity1 = {'domain_id': self.domainA['id'],
'local_id': local_id1,
'entity_type': mapping.EntityType.USER}
local_entity2 = {'domain_id': self.domainB['id'],
'local_id': local_id2,
'entity_type': mapping.EntityType.GROUP}
# Check no mappings for the new local entities
self.assertIsNone(
PROVIDERS.id_mapping_api.get_public_id(local_entity1)
)
self.assertIsNone(
PROVIDERS.id_mapping_api.get_public_id(local_entity2)
)
# Create the new mappings and then read them back
public_id1 = PROVIDERS.id_mapping_api.create_id_mapping(local_entity1)
public_id2 = PROVIDERS.id_mapping_api.create_id_mapping(local_entity2)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 2))
self.assertEqual(
public_id1, PROVIDERS.id_mapping_api.get_public_id(local_entity1))
self.assertEqual(
public_id2, PROVIDERS.id_mapping_api.get_public_id(local_entity2))
local_id_ref = PROVIDERS.id_mapping_api.get_id_mapping(public_id1)
self.assertEqual(self.domainA['id'], local_id_ref['domain_id'])
self.assertEqual(local_id1, local_id_ref['local_id'])
self.assertEqual(mapping.EntityType.USER, local_id_ref['entity_type'])
# Check we have really created a new external ID
self.assertNotEqual(local_id1, public_id1)
local_id_ref = PROVIDERS.id_mapping_api.get_id_mapping(public_id2)
self.assertEqual(self.domainB['id'], local_id_ref['domain_id'])
self.assertEqual(local_id2, local_id_ref['local_id'])
self.assertEqual(mapping.EntityType.GROUP, local_id_ref['entity_type'])
# Check we have really created a new external ID
self.assertNotEqual(local_id2, public_id2)
# Create another mappings, this time specifying a public ID to use
new_public_id = uuid.uuid4().hex
public_id3 = PROVIDERS.id_mapping_api.create_id_mapping(
{'domain_id': self.domainB['id'], 'local_id': local_id2,
'entity_type': mapping.EntityType.USER},
public_id=new_public_id)
self.assertEqual(new_public_id, public_id3)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 3))
# Delete the mappings we created, and make sure the mapping count
# goes back to where it was
PROVIDERS.id_mapping_api.delete_id_mapping(public_id1)
PROVIDERS.id_mapping_api.delete_id_mapping(public_id2)
PROVIDERS.id_mapping_api.delete_id_mapping(public_id3)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings))
def test_id_mapping_handles_unicode(self):
initial_mappings = len(mapping_sql.list_id_mappings())
local_id = u'fäké1'
local_entity = {'domain_id': self.domainA['id'],
'local_id': local_id,
'entity_type': mapping.EntityType.USER}
# Check no mappings for the new local entity
self.assertIsNone(self.id_mapping_api.get_public_id(local_entity))
# Create the new mapping and then read it back
public_id = self.id_mapping_api.create_id_mapping(local_entity)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 1))
self.assertEqual(
public_id, self.id_mapping_api.get_public_id(local_entity))
def test_id_mapping_handles_ids_greater_than_64_characters(self):
initial_mappings = len(mapping_sql.list_id_mappings())
local_id = 'Aa' * 100
local_entity = {'domain_id': self.domainA['id'],
'local_id': local_id,
'entity_type': mapping.EntityType.GROUP}
# Check no mappings for the new local entity
self.assertIsNone(PROVIDERS.id_mapping_api.get_public_id(local_entity))
# Create the new mapping and then read it back
public_id = PROVIDERS.id_mapping_api.create_id_mapping(local_entity)
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 1))
self.assertEqual(
public_id, PROVIDERS.id_mapping_api.get_public_id(local_entity))
self.assertEqual(
local_id,
PROVIDERS.id_mapping_api.get_id_mapping(public_id)['local_id'])
def test_purge_mappings(self):
initial_mappings = len(mapping_sql.list_id_mappings())
local_id1 = uuid.uuid4().hex
local_id2 = uuid.uuid4().hex
local_id3 = uuid.uuid4().hex
local_id4 = uuid.uuid4().hex
local_id5 = uuid.uuid4().hex
# Create five mappings,two in domainA, three in domainB
self.id_mapping_api.create_id_mapping(
{'domain_id': self.domainA['id'], 'local_id': local_id1,
'entity_type': mapping.EntityType.USER})
self.id_mapping_api.create_id_mapping(
{'domain_id': self.domainA['id'], 'local_id': local_id2,
'entity_type': mapping.EntityType.USER})
public_id3 = self.id_mapping_api.create_id_mapping(
{'domain_id': self.domainB['id'], 'local_id': local_id3,
'entity_type': mapping.EntityType.GROUP})
public_id4 = self.id_mapping_api.create_id_mapping(
{'domain_id': self.domainB['id'], 'local_id': local_id4,
'entity_type': mapping.EntityType.USER})
public_id5 = self.id_mapping_api.create_id_mapping(
{'domain_id': self.domainB['id'], 'local_id': local_id5,
'entity_type': mapping.EntityType.USER})
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 5))
# Purge mappings for domainA, should be left with those in B
self.id_mapping_api.purge_mappings(
{'domain_id': self.domainA['id']})
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 3))
self.id_mapping_api.get_id_mapping(public_id3)
self.id_mapping_api.get_id_mapping(public_id4)
self.id_mapping_api.get_id_mapping(public_id5)
# Purge mappings for type Group, should purge one more
self.id_mapping_api.purge_mappings(
{'entity_type': mapping.EntityType.GROUP})
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 2))
self.id_mapping_api.get_id_mapping(public_id4)
self.id_mapping_api.get_id_mapping(public_id5)
# Purge mapping for a specific local identifier
self.id_mapping_api.purge_mappings(
{'domain_id': self.domainB['id'], 'local_id': local_id4,
'entity_type': mapping.EntityType.USER})
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings + 1))
self.id_mapping_api.get_id_mapping(public_id5)
# Purge mappings the remaining mappings
self.id_mapping_api.purge_mappings({})
self.assertThat(mapping_sql.list_id_mappings(),
matchers.HasLength(initial_mappings))