170 lines
6.7 KiB
Python
170 lines
6.7 KiB
Python
# Copyright (c) 2014 VMware, Inc. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
|
|
from __future__ import print_function
|
|
from __future__ import division
|
|
from __future__ import absolute_import
|
|
|
|
from unittest import mock
|
|
|
|
from congress.datasources import keystonev3_driver
|
|
from congress.tests import base
|
|
from congress.tests.datasources import util
|
|
from congress.tests import helper
|
|
|
|
ResponseObj = util.ResponseObj
|
|
|
|
|
|
class TestKeystoneDriver(base.TestCase):
|
|
|
|
def setUp(self):
|
|
super(TestKeystoneDriver, self).setUp()
|
|
|
|
class FakeClient(object):
|
|
def __init__(self):
|
|
self.users = mock.MagicMock()
|
|
self.roles = mock.MagicMock()
|
|
self.projects = mock.MagicMock()
|
|
self.domains = mock.MagicMock()
|
|
|
|
self.users_data = [
|
|
ResponseObj({
|
|
'id': '00f2c34a156c40058004ee8eb3320e04',
|
|
'name': 'alice',
|
|
'enabled': True,
|
|
'default_project_id': '019b18a15f2a44c1880d57704b2c4009',
|
|
'domain_id': 'default'}),
|
|
ResponseObj({
|
|
'id': 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
|
|
'name': 'bob',
|
|
'enabled': False,
|
|
'default_project_id': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
|
|
'domain_id': 'default'})]
|
|
|
|
self.roles_data = [
|
|
ResponseObj({'id': 'cccccccccccccccccccccccccccccccc',
|
|
'name': 'admin'}),
|
|
ResponseObj({'id': 'dddddddddddddddddddddddddddddddd',
|
|
'name': 'viewer'})]
|
|
|
|
self.projects_data = [
|
|
ResponseObj({'enabled': True,
|
|
'description': 'accounting team',
|
|
'name': 'accounting',
|
|
'domain_id': 'default',
|
|
'id': '00000000000000000000000000000001'}),
|
|
ResponseObj({'enabled': False,
|
|
'description': 'eng team',
|
|
'domain_id': 'default',
|
|
'name': 'eng',
|
|
'id': '00000000000000000000000000000002'})]
|
|
|
|
self.domains_data = [
|
|
ResponseObj({'enabled': True,
|
|
'description': 'domain 1',
|
|
'name': 'default',
|
|
'id': '1fbe4e6fedb34050ad56c6e5dd225998'}),
|
|
|
|
ResponseObj({'enabled': False,
|
|
'description': 'domain 2',
|
|
'name': 'test domain',
|
|
'id': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})]
|
|
|
|
self.keystone_client = mock.patch("keystoneclient.v3.client.Client",
|
|
return_value=FakeClient())
|
|
self.keystone_client.start()
|
|
args = helper.datasource_openstack_args()
|
|
args['poll_time'] = 0
|
|
self.driver = keystonev3_driver.KeystoneV3Driver(args=args)
|
|
self.driver.client.users.list.return_value = self.users_data
|
|
self.driver.client.roles.list.return_value = self.roles_data
|
|
self.driver.client.projects.list.return_value = self.projects_data
|
|
self.driver.client.domains.list.return_value = self.domains_data
|
|
|
|
def test_list_users(self):
|
|
"""Test conversion of complex user objects to tables."""
|
|
self.driver.update_from_datasource()
|
|
user_list = self.driver.state[keystonev3_driver.KeystoneV3Driver.USERS]
|
|
self.assertIsNotNone(user_list)
|
|
self.assertEqual(2, len(user_list))
|
|
|
|
# Check an individual user entry
|
|
self.assertIn(('00f2c34a156c40058004ee8eb3320e04',
|
|
'alice', True, '019b18a15f2a44c1880d57704b2c4009',
|
|
'default'), user_list)
|
|
self.assertIn(('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
|
|
'bob', False, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
|
|
'default'), user_list)
|
|
|
|
def test_list_roles(self):
|
|
"""Test conversion of complex role objects to tables."""
|
|
self.driver.update_from_datasource()
|
|
roles_table = keystonev3_driver.KeystoneV3Driver.ROLES
|
|
roles_list = self.driver.state[roles_table]
|
|
self.assertIsNotNone(roles_list)
|
|
self.assertEqual(2, len(roles_list))
|
|
|
|
# Check an individual role entry
|
|
self.assertIn(('cccccccccccccccccccccccccccccccc', 'admin'),
|
|
roles_list)
|
|
self.assertIn(('dddddddddddddddddddddddddddddddd', 'viewer'),
|
|
roles_list)
|
|
|
|
def test_list_domains(self):
|
|
self.driver.update_from_datasource()
|
|
domains_table = keystonev3_driver.KeystoneV3Driver.DOMAINS
|
|
domains_list = self.driver.state[domains_table]
|
|
self.assertIsNotNone(domains_list)
|
|
self.assertEqual(2, len(domains_list))
|
|
|
|
# Check an individual role entry
|
|
self.assertIn((False, 'domain 2', 'test domain',
|
|
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'), domains_list)
|
|
self.assertIn((True, 'domain 1', 'default',
|
|
'1fbe4e6fedb34050ad56c6e5dd225998'), domains_list)
|
|
|
|
def test_list_projects(self):
|
|
"""Test conversion of complex tenant objects to tables."""
|
|
self.driver.update_from_datasource()
|
|
projects_table = keystonev3_driver.KeystoneV3Driver.PROJECTS
|
|
projects_list = self.driver.state[projects_table]
|
|
self.assertIsNotNone(projects_list)
|
|
self.assertEqual(2, len(projects_list))
|
|
|
|
# Check an individual role entry
|
|
self.assertIn((True, 'accounting team', 'accounting', 'default',
|
|
'00000000000000000000000000000001'), projects_list)
|
|
self.assertIn((False, 'eng team', 'eng', 'default',
|
|
'00000000000000000000000000000002'), projects_list)
|
|
|
|
def test_execute(self):
|
|
class KeystoneClient(object):
|
|
def __init__(self):
|
|
self.testkey = None
|
|
|
|
def enableProject(self, arg1):
|
|
self.testkey = 'arg1=%s' % arg1
|
|
|
|
keystone_client = KeystoneClient()
|
|
self.driver.client = keystone_client
|
|
api_args = {
|
|
'positional': ['1']
|
|
}
|
|
expected_ans = 'arg1=1'
|
|
|
|
self.driver.execute('enableProject', api_args)
|
|
|
|
self.assertEqual(expected_ans, keystone_client.testkey)
|