def test_get_current_project(self, mock_project, mock_current_project):
mock_current_project.return_value = CurrentProject()
project = Project('123', {})
project.id = 1
project.name = 'Nome'
mock_project.return_value = project
result_project = utils.get_current_project('1')
self.assertEqual(result_project.id, project.id)
self.assertEqual(result_project.name, project.name)
def test_set_current_project(self, mock_project):
project = Project('123', {})
project.id = 1
project.name = 'Teste'
mock_project.return_value = project
request = fake_request(method='GET')
request.user = UserFactory(id='999', username='******')
patch('identity.keystone.Keystone._create_keystone_connection').start()
project_name = request.session['project_name']
utils.set_current_project(request, project)
self.assertEqual(request.session['project_id'], 1)
self.assertEqual(request.session['project_name'], 'Teste')
def setUp(self):
self.request = fake_request()
self.user_id = 'abcdefghiklmnopq'
self.user_name = 'user_name'
self.project = Project(
'321', {
u'id': str(uuid4()),
u'name': 'project_test_delete',
u'description': 'project test delete description',
u'enabled': True
})
self.mock_keystone_conn = patch(
'identity.keystone.Keystone._create_keystone_connection').start()
self.mock_project_get_by_name = patch(
'identity.keystone.Keystone.project_get_by_name').start()
self.mock_project_get_by_name.return_value = self.project
self.mock_find_user_with_u_prefix = patch(
'identity.keystone.Keystone.find_user_with_u_prefix').start()
self.mock_find_user_with_u_prefix.return_value = FakeResource(
self.user_id, name=self.user_name)
def setUp(self):
self.request = fake_request()
self.project = Project(
'123', {
u'id': str(uuid4()),
u'name': 'project_test',
u'description': 'project description',
u'domain_id': 'default',
u'enabled': True
})
self.mock_project_create = patch(
'identity.keystone.Keystone.project_create').start()
self.mock_project_create.return_value = self.project
self.mock_project_update = patch(
'identity.keystone.Keystone.project_update').start()
self.mock_project_update.return_value = self.project
fake_project = FakeResource(n='abcdefg', name='fake_project')
fake_project.description = 'desc do fake'
self.mock_project_get = patch(
'identity.keystone.Keystone.project_get').start()
self.mock_project_get.return_value = fake_project
self.mock_keystone_conn = patch(
'identity.keystone.Keystone._create_keystone_connection').start()
self.group = GroupFactory(id=1)
def test_vault_create_project_forbidden_on_user_create(
self, mock_key_user, mock_project_delete, mock_project_create):
mock_project_create.return_value = Project('123', {
u'id': self.project.id,
u'name': self.project.name
})
mock_key_user.side_effect = exceptions.Forbidden
keystone = Keystone(self.request, project_name='project_name')
expected = {'status': False, 'reason': 'Admin User required'}
computed = keystone.vault_project_create(
self.project.name, 1, description=self.project.description)
self.assertEqual(computed, expected)
# Se falhou o cadastro de usuario, o project devera ser deletado
mock_project_delete.assert_called_with(self.project.id)
def generate_test_data():
''' Builds a set of test_data data as returned by Keystone V2. '''
test_data = TestDataContainer()
keystone_service = {
'type':
'identity',
'id':
uuid.uuid4().hex,
'endpoints': [{
'url': 'http://admin.localhost:35357/v3',
'region': 'RegionOne',
'interface': 'admin',
'id': uuid.uuid4().hex,
}, {
'url': 'http://internal.localhost:5000/v3',
'region': 'RegionOne',
'interface': 'internal',
'id': uuid.uuid4().hex
}, {
'url': 'http://public.localhost:5000/v3',
'region': 'RegionOne',
'interface': 'public',
'id': uuid.uuid4().hex
}]
}
# Domains
domain_dict = {
'id': uuid.uuid4().hex,
'name': 'domain',
'description': '',
'enabled': True
}
test_data.domain = Domain(DomainManager(None), domain_dict, loaded=True)
# Users
user_dict = {
'id': uuid.uuid4().hex,
'name': 'gabriel',
'email': '*****@*****.**',
'password': '******',
'domain_id': domain_dict['id'],
'token': '',
'enabled': True
}
test_data.user = User(UserManager(None), user_dict, loaded=True)
# Projects
project_dict_1 = {
'id': uuid.uuid4().hex,
'name': 'tenant_one',
'description': '',
'domain_id': domain_dict['id'],
'enabled': True
}
project_dict_2 = {
'id': uuid.uuid4().hex,
'name': '',
'description': '',
'domain_id': domain_dict['id'],
'enabled': False
}
test_data.project_one = Project(ProjectManager(None),
project_dict_1,
loaded=True)
test_data.project_two = Project(ProjectManager(None),
project_dict_2,
loaded=True)
# Roles
role_dict = {'id': uuid.uuid4().hex, 'name': 'Member'}
test_data.role = Role(RoleManager, role_dict)
nova_service = {
'type': 'compute',
'id': uuid.uuid4().hex,
'endpoints': [
{
'url': 'http://nova-admin.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region': 'RegionOne',
'interface': 'admin',
'id': uuid.uuid4().hex,
},
{
'url': 'http://nova-internal.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region': 'RegionOne',
'interface': 'internal',
'id': uuid.uuid4().hex
},
{
'url':'http://nova-public.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region':'RegionOne',
'interface': 'public',
'id': uuid.uuid4().hex
},
{
'url': 'http://nova2-admin.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region': 'RegionTwo',
'interface': 'admin',
'id': uuid.uuid4().hex,
},
{
'url': 'http://nova2-internal.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region': 'RegionTwo',
'interface': 'internal',
'id': uuid.uuid4().hex
},
{
'url':'http://nova2-public.localhost:8774/v2.0/%s' \
% (project_dict_1['id']),
'region':'RegionTwo',
'interface': 'public',
'id': uuid.uuid4().hex
}
]
}
# Tokens
tomorrow = datetime_safe.datetime.now() + timedelta(days=1)
expiration = datetime_safe.datetime.isoformat(tomorrow)
auth_token = uuid.uuid4().hex
auth_response_headers = {'X-Subject-Token': auth_token}
auth_response = TestResponse({"headers": auth_response_headers})
scoped_token_dict = {
'token': {
'methods': ['password'],
'expires_at': expiration,
'project': {
'id': project_dict_1['id'],
'name': project_dict_1['name'],
'domain': {
'id': domain_dict['id'],
'name': domain_dict['name']
}
},
'user': {
'id': user_dict['id'],
'name': user_dict['name'],
'domain': {
'id': domain_dict['id'],
'name': domain_dict['name']
}
},
'roles': [role_dict],
'catalog': [keystone_service, nova_service]
}
}
test_data.scoped_access_info = AccessInfo.factory(resp=auth_response,
body=scoped_token_dict)
unscoped_token_dict = {
'token': {
'methods': ['password'],
'expires_at': expiration,
'user': {
'id': user_dict['id'],
'name': user_dict['name'],
'domain': {
'id': domain_dict['id'],
'name': domain_dict['name']
}
},
'roles': [role_dict],
'catalog': [keystone_service]
}
}
test_data.unscoped_access_info = AccessInfo.factory(
resp=auth_response, body=unscoped_token_dict)
# Service Catalog
test_data.service_catalog = ServiceCatalog.factory(
{
'methods': ['password'],
'user': {},
'catalog': [keystone_service, nova_service],
},
token=auth_token)
return test_data