def __init__(self, **kwargs): """Initialize a new client for the Keystone v2.0 API.""" if not kwargs.get('session'): warnings.warn( 'Constructing an instance of the ' 'keystoneclient.v2_0.client.Client class without a session is ' 'deprecated as of the 1.7.0 release and may be removed in ' 'the 2.0.0 release.', DeprecationWarning) super(Client, self).__init__(**kwargs) self.certificates = certificates.CertificatesManager(self._adapter) self.endpoints = endpoints.EndpointManager(self._adapter) self.extensions = extensions.ExtensionManager(self._adapter) self.roles = roles.RoleManager(self._adapter) self.services = services.ServiceManager(self._adapter) self.tokens = tokens.TokenManager(self._adapter) self.users = users.UserManager(self._adapter, self.roles) self.tenants = tenants.TenantManager(self._adapter, self.roles, self.users) # extensions self.ec2 = ec2.CredentialsManager(self._adapter) # DEPRECATED: if session is passed then we go to the new behaviour of # authenticating on the first required call. if not kwargs.get('session') and self.management_url is None: self.authenticate()
def __init__(self, *args, **kwargs): super(V2IdentityClient, self).__init__(*args, **kwargs) self.endpoints = v2endpoints.EndpointManager(self) self.roles = v2roles.RoleManager(self) self.services = v2services.ServiceManager(self) self.tenants = v2tenants.TenantManager(self) self.tokens = v2tokens.TokenManager(self) self.users = v2users.UserManager(self)
def __init__(self, http_client, **kwargs): """ Initialize a new client for the Keystone v2.0 API. """ super(IdentityAdminClient, self).__init__(http_client) self.endpoints = endpoints.EndpointManager(self) self.roles = roles.RoleManager(self) self.services = services.ServiceManager(self) self.tenants = tenants.TenantManager(self) self.tokens = tokens.TokenManager(self) self.users = users.UserManager(self) # extensions self.ec2 = ec2.CredentialsManager(self)
def __init__(self, endpoint=None, **kwargs): """ Initialize a new client for the Keystone v2.0 API. """ super(Client, self).__init__(endpoint=endpoint, **kwargs) self.roles = roles.RoleManager(self) self.services = services.ServiceManager(self) self.tenants = tenants.TenantManager(self) self.tokens = tokens.TokenManager(self) self.users = users.UserManager(self) # NOTE(gabriel): If we have a pre-defined endpoint then we can # get away with lazy auth. Otherwise auth immediately. if endpoint is None: self.authenticate() else: self.management_url = endpoint
def __init__(self, **kwargs): """ Initialize a new client for the Keystone v2.0 API. """ super(Client, self).__init__(**kwargs) self.endpoints = endpoints.EndpointManager(self) self.roles = roles.RoleManager(self) self.services = services.ServiceManager(self) self.tenants = tenants.TenantManager(self) self.tokens = tokens.TokenManager(self) self.users = users.UserManager(self) # extensions self.ec2 = ec2.CredentialsManager(self) if self.management_url is None: self.authenticate()
def __init__(self, **kwargs): """Initialize a new client for the Keystone v2.0 API.""" super(Client, self).__init__(**kwargs) self.endpoints = endpoints.EndpointManager(self) self.roles = roles.RoleManager(self) self.services = services.ServiceManager(self) self.tenants = tenants.TenantManager(self) self.tokens = tokens.TokenManager(self) self.users = users.UserManager(self) # extensions self.ec2 = ec2.CredentialsManager(self) # DEPRECATED: if session is passed then we go to the new behaviour of # authenticating on the first required call. if not kwargs.get('session') and self.management_url is None: self.authenticate()
def __init__(self, **kwargs): """Initialize a new client for the Keystone v2.0 API.""" if not kwargs.get('session'): warnings.warn( 'Constructing an instance of the ' 'keystoneclient.v2_0.client.Client class without a session is ' 'deprecated as of the 1.7.0 release and may be removed in ' 'the 2.0.0 release.', DeprecationWarning) # NOTE(knasim-wrs): As per US76645, the Keystone adminURL # is no longer an internal address since it needs to be # accessible via remote Openstack client. Things get # complicated with HTTPS where the internal keystone client # gets this adminURL and cannot connect to Keystone server # as it cannot verify the SSL certificate. # We will check for this condition here, if OS_ENDPOINT_TYPE # is not publicURL then this is an internal access scenario and # Keystone client will be set to SSL insecure mode if os.environ.get('OS_ENDPOINT_TYPE') == 'internalURL': kwargs['insecure'] = True # disable verbose insecurity warnings urllib3_disable_warnings(InsecureRequestWarning) super(Client, self).__init__(**kwargs) self.certificates = certificates.CertificatesManager(self._adapter) self.endpoints = endpoints.EndpointManager(self._adapter) self.extensions = extensions.ExtensionManager(self._adapter) self.roles = roles.RoleManager(self._adapter) self.services = services.ServiceManager(self._adapter) self.tokens = tokens.TokenManager(self._adapter) self.users = users.UserManager(self._adapter, self.roles) self.tenants = tenants.TenantManager(self._adapter, self.roles, self.users) # extensions self.ec2 = ec2.CredentialsManager(self._adapter) # DEPRECATED: if session is passed then we go to the new behaviour of # authenticating on the first required call. if not kwargs.get('session') and self.management_url is None: self.authenticate()
def setUp(self): self.m = mox.Mox() self.fc = fakes.FakeClient() self.fc.users = users.UserManager(None) self.fc.roles = roles.RoleManager(None) self.fc.ec2 = ec2.CredentialsManager(None) self.m.StubOutWithMock(user.User, 'keystone') self.m.StubOutWithMock(user.AccessKey, 'keystone') self.m.StubOutWithMock(self.fc.users, 'create') self.m.StubOutWithMock(self.fc.users, 'get') self.m.StubOutWithMock(self.fc.users, 'delete') self.m.StubOutWithMock(self.fc.users, 'list') self.m.StubOutWithMock(self.fc.roles, 'list') self.m.StubOutWithMock(self.fc.roles, 'add_user_role') self.m.StubOutWithMock(self.fc.ec2, 'create') self.m.StubOutWithMock(self.fc.ec2, 'get') self.m.StubOutWithMock(self.fc.ec2, 'delete') self.m.StubOutWithMock(eventlet, 'sleep') config.register_engine_opts() cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
def data(TEST): TEST.service_catalog = SERVICE_CATALOG TEST.tokens = TestDataContainer() TEST.domains = TestDataContainer() TEST.users = TestDataContainer() TEST.groups = TestDataContainer() TEST.tenants = TestDataContainer() TEST.roles = TestDataContainer() TEST.ec2 = TestDataContainer() admin_role_dict = {'id': '1', 'name': 'admin'} admin_role = roles.Role(roles.RoleManager, admin_role_dict) member_role_dict = { 'id': "2", 'name': settings.OPENSTACK_KEYSTONE_DEFAULT_ROLE } member_role = roles.Role(roles.RoleManager, member_role_dict) TEST.roles.add(admin_role, member_role) TEST.roles.admin = admin_role TEST.roles.member = member_role domain_dict = { 'id': "1", 'name': 'test_domain', 'description': "a test domain.", 'enabled': True } domain_dict_2 = { 'id': "2", 'name': 'disabled_domain', 'description': "a disabled test domain.", 'enabled': False } domain = domains.Domain(domains.DomainManager, domain_dict) disabled_domain = domains.Domain(domains.DomainManager, domain_dict_2) TEST.domains.add(domain, disabled_domain) TEST.domain = domain # Your "current" domain user_dict = { 'id': "1", 'name': 'test_user', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True, 'domain_id': "1" } user = users.User(users.UserManager(None), user_dict) user_dict = { 'id': "2", 'name': 'user_two', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True, 'domain_id': "1" } user2 = users.User(users.UserManager(None), user_dict) user_dict = { 'id': "3", 'name': 'user_three', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True, 'domain_id': "1" } user3 = users.User(users.UserManager(None), user_dict) user_dict = { 'id': "4", 'name': 'user_four', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '2', 'enabled': True, 'domain_id': "2" } user4 = users.User(users.UserManager(None), user_dict) TEST.users.add(user, user2, user3, user4) TEST.user = user # Your "current" user TEST.user.service_catalog = SERVICE_CATALOG group_dict = { 'id': "1", 'name': 'group_one', 'description': 'group one description', 'domain_id': '1' } group = groups.Group(groups.GroupManager(None), group_dict) group_dict = { 'id': "2", 'name': 'group_two', 'description': 'group two description', 'domain_id': '1' } group2 = groups.Group(groups.GroupManager(None), group_dict) group_dict = { 'id': "3", 'name': 'group_three', 'description': 'group three description', 'domain_id': '2' } group3 = groups.Group(groups.GroupManager(None), group_dict) TEST.groups.add(group, group2, group3) tenant_dict = { 'id': "1", 'name': 'test_tenant', 'description': "a test tenant.", 'enabled': True, 'domain_id': '1' } tenant_dict_2 = { 'id': "2", 'name': 'disabled_tenant', 'description': "a disabled test tenant.", 'enabled': False, 'domain_id': '2' } tenant_dict_3 = { 'id': "3", 'name': u'\u4e91\u89c4\u5219', 'description': "an unicode-named tenant.", 'enabled': True, 'domain_id': '2' } tenant = tenants.Tenant(tenants.TenantManager, tenant_dict) disabled_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict_2) tenant_unicode = tenants.Tenant(tenants.TenantManager, tenant_dict_3) TEST.tenants.add(tenant, disabled_tenant, tenant_unicode) TEST.tenant = tenant # Your "current" tenant tomorrow = datetime_safe.datetime.now() + timedelta(days=1) expiration = datetime_safe.datetime.isoformat(tomorrow) scoped_token_dict = { 'access': { 'token': { 'id': "test_token_id", 'expires': expiration, 'tenant': tenant_dict, 'tenants': [tenant_dict] }, 'user': { 'id': "test_user_id", 'name': "test_user", 'roles': [member_role_dict] }, 'serviceCatalog': TEST.service_catalog } } scoped_access_info = AccessInfo.factory(resp=None, body=scoped_token_dict) unscoped_token_dict = { 'access': { 'token': { 'id': "test_token_id", 'expires': expiration }, 'user': { 'id': "test_user_id", 'name': "test_user", 'roles': [member_role_dict] }, 'serviceCatalog': TEST.service_catalog } } unscoped_access_info = AccessInfo.factory(resp=None, body=unscoped_token_dict) scoped_token = Token(scoped_access_info) unscoped_token = Token(unscoped_access_info) TEST.tokens.add(scoped_token, unscoped_token) TEST.token = scoped_token # your "current" token. TEST.tokens.scoped_token = scoped_token TEST.tokens.unscoped_token = unscoped_token access_secret = ec2.EC2(ec2.CredentialsManager, { "access": "access", "secret": "secret" }) TEST.ec2.add(access_secret)
def data(TEST): TEST.ceilometer_users = utils.TestDataContainer() TEST.ceilometer_tenants = utils.TestDataContainer() TEST.resources = utils.TestDataContainer() TEST.samples = utils.TestDataContainer() TEST.meters = utils.TestDataContainer() TEST.statistics = utils.TestDataContainer() TEST.global_disk_usages = utils.TestDataContainer() TEST.global_network_usages = utils.TestDataContainer() TEST.global_network_traffic_usages = utils.TestDataContainer() TEST.global_object_store_usages = utils.TestDataContainer() TEST.statistics_array = utils.TestDataContainer() # users ceilometer_user_dict1 = {'id': "1", 'name': 'user', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True, 'domain_id': "1"} ceilometer_user_dict2 = {'id': "2", 'name': 'user2', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '2', 'enabled': True, 'domain_id': "2"} TEST.ceilometer_users.add(users.User(users.UserManager(None), ceilometer_user_dict1)) TEST.ceilometer_users.add(users.User(users.UserManager(None), ceilometer_user_dict2)) #tenants tenant_dict = {'id': "1", 'name': 'test_tenant', 'description': "a test tenant.", 'enabled': True, 'domain_id': '1'} tenant_dict_2 = {'id': "2", 'name': 'disabled_tenant', 'description': "a disabled test tenant.", 'enabled': False, 'domain_id': '2'} tenant_dict_3 = {'id': "3", 'name': u'\u4e91\u89c4\u5219', 'description': "an unicode-named tenant.", 'enabled': True, 'domain_id': '2'} ceilometer_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict) ceilometer_disabled_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict_2) ceilometer_tenant_unicode = tenants.Tenant(tenants.TenantManager, tenant_dict_3) TEST.ceilometer_tenants.add(ceilometer_tenant, ceilometer_disabled_tenant, ceilometer_tenant_unicode) # resources resource_dict_1 = dict( resource_id='fake_resource_id', project_id='fake_project_id', user_id="fake_user_id", timestamp='2012-07-02T10:42:00.000000', metadata={'tag': 'self.counter3', 'display_name': 'test-server'}, links=[{'url': 'test_url', 'rel': 'storage.objects'}], ) resource_dict_2 = dict( resource_id='fake_resource_id2', project_id='fake_project_id', user_id="fake_user_id", timestamp='2012-07-02T10:42:00.000000', metadata={'tag': 'self.counter3', 'display_name': 'test-server'}, links=[{'url': 'test_url', 'rel': 'storage.objects'}], ) resource_dict_3 = dict( resource_id='fake_resource_id3', project_id='fake_project_id', user_id="fake_user_id", timestamp='2012-07-02T10:42:00.000000', metadata={'tag': 'self.counter3', 'display_name': 'test-server'}, links=[{'url': 'test_url', 'rel': 'intance'}], ) resource_1 = resources.Resource(resources.ResourceManager(None), resource_dict_1) resource_2 = resources.Resource(resources.ResourceManager(None), resource_dict_2) resource_3 = resources.Resource(resources.ResourceManager(None), resource_dict_3) TEST.resources.add(resource_1) TEST.resources.add(resource_2) TEST.resources.add(resource_3) # samples sample_dict_1 = {'resource_id': 'fake_resource_id', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id', 'counter_name': 'image', 'counter_type': 'gauge', 'counter_unit': 'image', 'counter_volume': 1, 'timestamp': '2012-12-21T11:00:55.000000', 'metadata': {'name1': 'value1', 'name2': 'value2'}, 'message_id': 'fake_message_id'} sample_dict_2 = {'resource_id': 'fake_resource_id2', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id', 'counter_name': 'image', 'counter_type': 'gauge', 'counter_unit': 'image', 'counter_volume': 1, 'timestamp': '2012-12-21T11:00:55.000000', 'metadata': {'name1': 'value1', 'name2': 'value2'}, 'message_id': 'fake_message_id'} sample_1 = samples.Sample(samples.SampleManager(None), sample_dict_1) sample_2 = samples.Sample(samples.SampleManager(None), sample_dict_2) TEST.samples.add(sample_1) TEST.samples.add(sample_2) # meters meter_dict_1 = {'name': 'instance', 'type': 'gauge', 'unit': 'instance', 'resource_id': 'fake_resource_id', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id'} meter_dict_2 = {'name': 'instance', 'type': 'gauge', 'unit': 'instance', 'resource_id': 'fake_resource_id', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id'} meter_dict_3 = {'name': 'disk.read.bytes', 'type': 'gauge', 'unit': 'instance', 'resource_id': 'fake_resource_id', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id'} meter_dict_4 = {'name': 'disk.write.bytes', 'type': 'gauge', 'unit': 'instance', 'resource_id': 'fake_resource_id', 'project_id': 'fake_project_id', 'user_id': 'fake_user_id'} meter_1 = meters.Meter(meters.MeterManager(None), meter_dict_1) meter_2 = meters.Meter(meters.MeterManager(None), meter_dict_2) meter_3 = meters.Meter(meters.MeterManager(None), meter_dict_3) meter_4 = meters.Meter(meters.MeterManager(None), meter_dict_4) TEST.meters.add(meter_1) TEST.meters.add(meter_2) TEST.meters.add(meter_3) TEST.meters.add(meter_4) # statistic statistic_dict_1 = {'min': 1, 'max': 9, 'avg': 4.55, 'sum': 45, 'count': 10, 'duration_start': '2012-12-21T11:00:55.000000', 'duration_end': '2012-12-21T11:00:55.000000', 'period': 7200, 'period_start': '2012-12-21T11:00:55.000000', 'period_end': '2012-12-21T11:00:55.000000'} statistic_1 = statistics.Statistics(statistics.StatisticsManager(None), statistic_dict_1) TEST.statistics.add(statistic_1)
def generate_test_data(): ''' Builds a set of test_data data as returned by Keystone V2. ''' test_data = TestDataContainer() keystone_service = { 'type': 'identity', 'name': 'keystone', 'endpoints_links': [], 'endpoints': [{ 'region': 'RegionOne', 'adminURL': 'http://admin.localhost:35357/v2.0', 'internalURL': 'http://internal.localhost:5000/v2.0', 'publicURL': 'http://public.localhost:5000/v2.0' }] } # Users user_dict = { 'id': uuid.uuid4().hex, 'name': 'gabriel', 'email': '*****@*****.**', 'password': '******', 'token': '', 'enabled': True } test_data.user = users.User(users.UserManager(None), user_dict, loaded=True) # Tenants tenant_dict_1 = { 'id': uuid.uuid4().hex, 'name': 'tenant_one', 'description': '', 'enabled': True } tenant_dict_2 = { 'id': uuid.uuid4().hex, 'name': 'tenant_two', 'description': '', 'enabled': False } test_data.tenant_one = tenants.Tenant(tenants.TenantManager(None), tenant_dict_1, loaded=True) test_data.tenant_two = tenants.Tenant(tenants.TenantManager(None), tenant_dict_2, loaded=True) nova_service = { 'type': 'compute', 'name': 'nova', 'endpoint_links': [], 'endpoints': [{ 'region': 'RegionOne', 'adminURL': ('http://nova-admin.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])), 'internalURL': ('http://nova-internal.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])), 'publicURL': ('http://nova-public.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])) }, { 'region': 'RegionTwo', 'adminURL': ('http://nova2-admin.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])), 'internalURL': ('http://nova2-internal.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])), 'publicURL': ('http://nova2-public.localhost:8774/v2.0/%s' % (tenant_dict_1['id'])) }] } # Roles role_dict = {'id': uuid.uuid4().hex, 'name': 'Member'} test_data.role = roles.Role(roles.RoleManager, role_dict) # Tokens tomorrow = datetime_safe.datetime.now() + datetime.timedelta(days=1) expiration = datetime_safe.datetime.isoformat(tomorrow) scoped_token_dict = { 'access': { 'token': { 'id': uuid.uuid4().hex, 'expires': expiration, 'tenant': tenant_dict_1, 'tenants': [tenant_dict_1, tenant_dict_2] }, 'user': { 'id': user_dict['id'], 'name': user_dict['name'], 'roles': [role_dict] }, 'serviceCatalog': [keystone_service, nova_service] } } test_data.scoped_access_info = access.AccessInfo.factory( resp=None, body=scoped_token_dict) unscoped_token_dict = { 'access': { 'token': { 'id': uuid.uuid4().hex, 'expires': expiration }, 'user': { 'id': user_dict['id'], 'name': user_dict['name'], 'roles': [role_dict] }, 'serviceCatalog': [keystone_service] } } test_data.unscoped_access_info = access.AccessInfo.factory( resp=None, body=unscoped_token_dict) # Service Catalog test_data.service_catalog = service_catalog.ServiceCatalog.factory({ 'serviceCatalog': [keystone_service, nova_service], 'token': { 'id': scoped_token_dict['access']['token']['id'], 'expires': scoped_token_dict['access']['token']['expires'], 'user_id': user_dict['id'], 'tenant_id': tenant_dict_1['id'] } }) return test_data
def data(TEST): TEST.service_catalog = SERVICE_CATALOG TEST.tokens = TestDataContainer() TEST.domains = TestDataContainer() TEST.users = TestDataContainer() TEST.tenants = TestDataContainer() TEST.roles = TestDataContainer() TEST.ec2 = TestDataContainer() admin_role_dict = {'id': '1', 'name': 'admin'} admin_role = roles.Role(roles.RoleManager, admin_role_dict) member_role_dict = {'id': "2", 'name': settings.OPENSTACK_KEYSTONE_DEFAULT_ROLE} member_role = roles.Role(roles.RoleManager, member_role_dict) TEST.roles.add(admin_role, member_role) TEST.roles.admin = admin_role TEST.roles.member = member_role domain_dict = {'id': "1", 'name': 'test_domain', 'description': "a test domain.", 'enabled': True} domain_dict_2 = {'id': "2", 'name': 'disabled_domain', 'description': "a disabled test domain.", 'enabled': False} domain = domains.Domain(domains.DomainManager, domain_dict) disabled_domain = domains.Domain(domains.DomainManager, domain_dict_2) TEST.domains.add(domain, disabled_domain) TEST.domain = domain # Your "current" domain user_dict = {'id': "1", 'name': 'test_user', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True} user = users.User(users.UserManager(None), user_dict) user_dict = {'id': "2", 'name': 'user_two', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True} user2 = users.User(users.UserManager(None), user_dict) user_dict = {'id': "3", 'name': 'user_three', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'project_id': '1', 'enabled': True} user3 = users.User(users.UserManager(None), user_dict) TEST.users.add(user, user2, user3) TEST.user = user # Your "current" user TEST.user.service_catalog = SERVICE_CATALOG tenant_dict = {'id': "1", 'name': 'test_tenant', 'description': "a test tenant.", 'enabled': True} tenant_dict_2 = {'id': "2", 'name': 'disabled_tenant', 'description': "a disabled test tenant.", 'enabled': False} tenant = tenants.Tenant(tenants.TenantManager, tenant_dict) disabled_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict_2) TEST.tenants.add(tenant, disabled_tenant) TEST.tenant = tenant # Your "current" tenant tomorrow = datetime_safe.datetime.now() + timedelta(days=1) expiration = datetime_safe.datetime.isoformat(tomorrow) scoped_token = tokens.Token(tokens.TokenManager, dict(token={"id": "test_token_id", "expires": expiration, "tenant": tenant_dict, "tenants": [tenant_dict]}, user={"id": "test_user_id", "name": "test_user", "roles": [member_role_dict]}, serviceCatalog=TEST.service_catalog)) unscoped_token = tokens.Token(tokens.TokenManager, dict(token={"id": "test_token_id", "expires": expiration}, user={"id": "test_user_id", "name": "test_user", "roles": [member_role_dict]}, serviceCatalog=TEST.service_catalog)) TEST.tokens.add(scoped_token, unscoped_token) TEST.token = scoped_token # your "current" token. TEST.tokens.scoped_token = scoped_token TEST.tokens.unscoped_token = unscoped_token access_secret = ec2.EC2(ec2.CredentialsManager, {"access": "access", "secret": "secret"}) TEST.ec2.add(access_secret)
def data(TEST): TEST.service_catalog = SERVICE_CATALOG TEST.tokens = TestDataContainer() TEST.users = TestDataContainer() TEST.tenants = TestDataContainer() TEST.roles = TestDataContainer() TEST.ec2 = TestDataContainer() admin_role_dict = {'id': '1', 'name': 'admin'} admin_role = roles.Role(roles.RoleManager, admin_role_dict) member_role_dict = {'id': "2", 'name': settings.OPENSTACK_KEYSTONE_DEFAULT_ROLE} member_role = roles.Role(roles.RoleManager, member_role_dict) TEST.roles.add(member_role, admin_role) TEST.roles.admin = admin_role TEST.roles.member = member_role user_dict = {'id': "1", 'name': 'test_user', 'email': '*****@*****.**', 'password': '******', 'token': 'test_token', 'enabled': True} user = users.User(users.UserManager(None), user_dict) user_dict.update({'id': "2", 'name': 'user_two', 'email': '*****@*****.**'}) user2 = users.User(users.UserManager(None), user_dict) TEST.users.add(user, user2) TEST.user = user # Your "current" user TEST.user.service_catalog = SERVICE_CATALOG tenant_dict = {'id': "1", 'name': 'test_tenant', 'description': "a test tenant.", 'enabled': True} tenant_dict_2 = {'id': "2", 'name': 'disabled_tenant', 'description': "a disabled test tenant.", 'enabled': False} tenant = tenants.Tenant(tenants.TenantManager, tenant_dict) disabled_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict_2) TEST.tenants.add(tenant, disabled_tenant) TEST.tenant = tenant # Your "current" tenant scoped_token = tokens.Token(tokens.TokenManager, dict(token={"id": "test_token_id", "expires": "#FIXME", "tenant": tenant_dict, "tenants": [tenant_dict]}, user={"id": "test_user_id", "name": "test_user", "roles": [member_role_dict]}, serviceCatalog=TEST.service_catalog)) unscoped_token = tokens.Token(tokens.TokenManager, dict(token={"id": "test_token_id", "expires": "#FIXME"}, user={"id": "test_user_id", "name": "test_user", "roles": [member_role_dict]}, serviceCatalog=TEST.service_catalog)) TEST.tokens.add(scoped_token, unscoped_token) TEST.token = scoped_token # your "current" token. TEST.tokens.scoped_token = scoped_token TEST.tokens.unscoped_token = unscoped_token access_secret = ec2.EC2(ec2.CredentialsManager, {"access": "access", "secret": "secret"}) TEST.ec2.add(access_secret)