diff options
Diffstat (limited to 'openstackclient/tests')
| -rw-r--r-- | openstackclient/tests/identity/v2_0/test_role.py | 10 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/__init__.py | 14 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/fakes.py | 106 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/test_identity.py | 31 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/test_project.py | 531 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/test_role.py | 550 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/test_service.py | 408 | ||||
| -rw-r--r-- | openstackclient/tests/identity/v3/test_user.py | 986 |
8 files changed, 2635 insertions, 1 deletions
diff --git a/openstackclient/tests/identity/v2_0/test_role.py b/openstackclient/tests/identity/v2_0/test_role.py index 58de8e52..56e9d4cb 100644 --- a/openstackclient/tests/identity/v2_0/test_role.py +++ b/openstackclient/tests/identity/v2_0/test_role.py @@ -31,9 +31,11 @@ class TestRole(test_identity.TestIdentityv2): # Get a shortcut to the TenantManager Mock self.projects_mock = self.app.client_manager.identity.tenants self.projects_mock.reset_mock() + # Get a shortcut to the UserManager Mock self.users_mock = self.app.client_manager.identity.users self.users_mock.reset_mock() + # Get a shortcut to the RoleManager Mock self.roles_mock = self.app.client_manager.identity.roles self.roles_mock.reset_mock() @@ -49,11 +51,13 @@ class TestRoleAdd(TestRole): copy.deepcopy(identity_fakes.PROJECT), loaded=True, ) + self.users_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.USER), loaded=True, ) + self.roles_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE), @@ -75,9 +79,9 @@ class TestRoleAdd(TestRole): identity_fakes.role_name, ] verifylist = [ - ('role', identity_fakes.role_name), ('project', identity_fakes.project_name), ('user', identity_fakes.user_name), + ('role', identity_fakes.role_name), ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) @@ -217,11 +221,13 @@ class TestUserRoleList(TestRole): copy.deepcopy(identity_fakes.PROJECT), loaded=True, ) + self.users_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.USER), loaded=True, ) + self.roles_mock.roles_for_user.return_value = [ fakes.FakeResource( None, @@ -340,11 +346,13 @@ class TestRoleRemove(TestRole): copy.deepcopy(identity_fakes.PROJECT), loaded=True, ) + self.users_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.USER), loaded=True, ) + self.roles_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.ROLE), diff --git a/openstackclient/tests/identity/v3/__init__.py b/openstackclient/tests/identity/v3/__init__.py new file mode 100644 index 00000000..c534c012 --- /dev/null +++ b/openstackclient/tests/identity/v3/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2013 OpenStack Foundation +# +# 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. +# diff --git a/openstackclient/tests/identity/v3/fakes.py b/openstackclient/tests/identity/v3/fakes.py new file mode 100644 index 00000000..13385536 --- /dev/null +++ b/openstackclient/tests/identity/v3/fakes.py @@ -0,0 +1,106 @@ +# Copyright 2013 Nebula Inc. +# +# 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. +# + +import mock + +from openstackclient.tests import fakes + + +domain_id = 'd1' +domain_name = 'oftheking' + +DOMAIN = { + 'id': domain_id, + 'name': domain_name, +} + +group_id = 'gr-010' +group_name = 'spencer davis' + +GROUP = { + 'id': group_id, + 'name': group_name, +} + +project_id = '8-9-64' +project_name = 'beatles' +project_description = 'Fab Four' + +PROJECT = { + 'id': project_id, + 'name': project_name, + 'description': project_description, + 'enabled': True, + 'domain_id': domain_id, +} + +PROJECT_2 = { + 'id': project_id + '-2222', + 'name': project_name + ' reprise', + 'description': project_description + 'plus four more', + 'enabled': True, + 'domain_id': domain_id, +} + +role_id = 'r1' +role_name = 'roller' + +ROLE = { + 'id': role_id, + 'name': role_name, +} + +service_id = 's-123' +service_name = 'Texaco' +service_type = 'gas' + +SERVICE = { + 'id': service_id, + 'name': service_name, + 'type': service_type, + 'enabled': True, +} + +user_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' +user_name = 'paul' +user_description = 'Sir Paul' +user_email = 'paul@applecorps.com' + +USER = { + 'id': user_id, + 'name': user_name, + 'project_id': project_id, + 'email': user_email, + 'enabled': True, + 'domain_id': domain_id, +} + + +class FakeIdentityv3Client(object): + def __init__(self, **kwargs): + self.domains = mock.Mock() + self.domains.resource_class = fakes.FakeResource(None, {}) + self.groups = mock.Mock() + self.groups.resource_class = fakes.FakeResource(None, {}) + self.projects = mock.Mock() + self.projects.resource_class = fakes.FakeResource(None, {}) + self.roles = mock.Mock() + self.roles.resource_class = fakes.FakeResource(None, {}) + self.services = mock.Mock() + self.services.resource_class = fakes.FakeResource(None, {}) + self.users = mock.Mock() + self.users.resource_class = fakes.FakeResource(None, {}) + self.auth_token = kwargs['token'] + self.management_url = kwargs['endpoint'] diff --git a/openstackclient/tests/identity/v3/test_identity.py b/openstackclient/tests/identity/v3/test_identity.py new file mode 100644 index 00000000..4b55ee45 --- /dev/null +++ b/openstackclient/tests/identity/v3/test_identity.py @@ -0,0 +1,31 @@ +# Copyright 2013 Nebula Inc. +# +# 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 openstackclient.tests.identity.v3 import fakes +from openstackclient.tests import utils + + +AUTH_TOKEN = "foobar" +AUTH_URL = "http://0.0.0.0" + + +class TestIdentityv3(utils.TestCommand): + def setUp(self): + super(TestIdentityv3, self).setUp() + + self.app.client_manager.identity = fakes.FakeIdentityv3Client( + endpoint=AUTH_URL, + token=AUTH_TOKEN, + ) diff --git a/openstackclient/tests/identity/v3/test_project.py b/openstackclient/tests/identity/v3/test_project.py new file mode 100644 index 00000000..91c15e24 --- /dev/null +++ b/openstackclient/tests/identity/v3/test_project.py @@ -0,0 +1,531 @@ +# Copyright 2013 Nebula Inc. +# +# 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. +# + +import copy + +from openstackclient.identity.v3 import project +from openstackclient.tests import fakes +from openstackclient.tests.identity.v3 import fakes as identity_fakes +from openstackclient.tests.identity.v3 import test_identity + + +class TestProject(test_identity.TestIdentityv3): + + def setUp(self): + super(TestProject, self).setUp() + + # Get a shortcut to the DomainManager Mock + self.domains_mock = self.app.client_manager.identity.domains + self.domains_mock.reset_mock() + + # Get a shortcut to the ProjectManager Mock + self.projects_mock = self.app.client_manager.identity.projects + self.projects_mock.reset_mock() + + +class TestProjectCreate(TestProject): + + def setUp(self): + super(TestProjectCreate, self).setUp() + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.create.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + # Get the command object to test + self.cmd = project.CreateProject(self.app, None) + + def test_project_create_no_options(self): + arglist = [ + identity_fakes.project_name, + ] + verifylist = [ + ('enable', False), + ('disable', False), + ('name', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'description': None, + 'enabled': True, + } + # ProjectManager.create(name, domain, description=, enabled=, **kwargs) + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + None, + **kwargs + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) + + def test_project_create_description(self): + arglist = [ + '--description', 'new desc', + identity_fakes.project_name, + ] + verifylist = [ + ('description', 'new desc'), + ('enable', False), + ('disable', False), + ('name', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'description': 'new desc', + 'enabled': True, + } + # ProjectManager.create(name, domain, description=, enabled=, **kwargs) + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + None, + **kwargs + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) + + def test_project_create_domain(self): + arglist = [ + '--domain', identity_fakes.domain_name, + identity_fakes.project_name, + ] + verifylist = [ + ('domain', identity_fakes.domain_name), + ('enable', False), + ('disable', False), + ('name', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'description': None, + 'enabled': True, + } + # ProjectManager.create(name, domain, description=, enabled=, **kwargs) + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + identity_fakes.domain_id, + **kwargs + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) + + def test_project_create_enable(self): + arglist = [ + '--enable', + identity_fakes.project_name, + ] + verifylist = [ + ('enable', True), + ('disable', False), + ('name', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'description': None, + 'enabled': True, + } + # ProjectManager.create(name, domain, description=, enabled=, **kwargs) + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + None, + **kwargs + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) + + def test_project_create_disable(self): + arglist = [ + '--disable', + identity_fakes.project_name, + ] + verifylist = [ + ('enable', False), + ('disable', True), + ('name', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'description': None, + 'enabled': False, + } + # ProjectManager.create(name, domain, description=, enabled=, **kwargs) + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + None, + **kwargs + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) + + +class TestProjectDelete(TestProject): + + def setUp(self): + super(TestProjectDelete, self).setUp() + + # This is the return value for utils.find_resource() + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + self.projects_mock.delete.return_value = None + + # Get the command object to test + self.cmd = project.DeleteProject(self.app, None) + + def test_project_delete_no_options(self): + arglist = [ + identity_fakes.project_id, + ] + verifylist = [ + ('project', identity_fakes.project_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + self.projects_mock.delete.assert_called_with( + identity_fakes.project_id, + ) + + +class TestProjectList(TestProject): + + def setUp(self): + super(TestProjectList, self).setUp() + + self.projects_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ), + ] + + # Get the command object to test + self.cmd = project.ListProject(self.app, None) + + def test_project_list_no_options(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + self.projects_mock.list.assert_called_with() + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.project_id, + identity_fakes.project_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_project_list_long(self): + arglist = [ + '--long', + ] + verifylist = [ + ('long', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + self.projects_mock.list.assert_called_with() + + collist = ('ID', 'Name', 'Domain ID', 'Description', 'Enabled') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.project_id, + identity_fakes.project_name, + identity_fakes.domain_id, + identity_fakes.project_description, + True, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestProjectSet(TestProject): + + def setUp(self): + super(TestProjectSet, self).setUp() + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + self.projects_mock.update.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + # Get the command object to test + self.cmd = project.SetProject(self.app, None) + + def test_project_set_no_options(self): + arglist = [ + identity_fakes.project_name, + ] + verifylist = [ + ('project', identity_fakes.project_name), + ('enable', False), + ('disable', False), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + def test_project_set_name(self): + arglist = [ + '--name', 'qwerty', + identity_fakes.project_name, + ] + verifylist = [ + ('name', 'qwerty'), + ('enable', False), + ('disable', False), + ('project', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'description': identity_fakes.project_description, + 'domain': identity_fakes.domain_id, + 'enabled': True, + 'name': 'qwerty', + } + # ProjectManager.update(project, name=, domain=, description=, + # enabled=, **kwargs) + self.projects_mock.update.assert_called_with( + identity_fakes.project_id, + **kwargs + ) + + def test_project_set_description(self): + arglist = [ + '--description', 'new desc', + identity_fakes.project_name, + ] + verifylist = [ + ('description', 'new desc'), + ('enable', False), + ('disable', False), + ('project', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'description': 'new desc', + 'domain': identity_fakes.domain_id, + 'enabled': True, + 'name': identity_fakes.project_name, + } + self.projects_mock.update.assert_called_with( + identity_fakes.project_id, + **kwargs + ) + + def test_project_set_enable(self): + arglist = [ + '--enable', + identity_fakes.project_name, + ] + verifylist = [ + ('enable', True), + ('disable', False), + ('project', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'description': identity_fakes.project_description, + 'domain': identity_fakes.domain_id, + 'enabled': True, + 'name': identity_fakes.project_name, + } + self.projects_mock.update.assert_called_with( + identity_fakes.project_id, + **kwargs + ) + + def test_project_set_disable(self): + arglist = [ + '--disable', + identity_fakes.project_name, + ] + verifylist = [ + ('enable', False), + ('disable', True), + ('project', identity_fakes.project_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'description': identity_fakes.project_description, + 'domain': identity_fakes.domain_id, + 'enabled': False, + 'name': identity_fakes.project_name, + } + self.projects_mock.update.assert_called_with( + identity_fakes.project_id, + **kwargs + ) + + +class TestProjectShow(TestProject): + + def setUp(self): + super(TestProjectShow, self).setUp() + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + # Get the command object to test + self.cmd = project.ShowProject(self.app, None) + + def test_project_show(self): + arglist = [ + identity_fakes.project_id, + ] + verifylist = [ + ('project', identity_fakes.project_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + self.projects_mock.get.assert_called_with( + identity_fakes.project_id, + ) + + collist = ('description', 'domain_id', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + identity_fakes.domain_id, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v3/test_role.py b/openstackclient/tests/identity/v3/test_role.py new file mode 100644 index 00000000..ef2b3e05 --- /dev/null +++ b/openstackclient/tests/identity/v3/test_role.py @@ -0,0 +1,550 @@ +# Copyright 2013 Nebula Inc. +# +# 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. +# + +import copy + +from openstackclient.identity.v3 import role +from openstackclient.tests import fakes +from openstackclient.tests.identity.v3 import fakes as identity_fakes +from openstackclient.tests.identity.v3 import test_identity + + +class TestRole(test_identity.TestIdentityv3): + + def setUp(self): + super(TestRole, self).setUp() + + # Get a shortcut to the UserManager Mock + self.users_mock = self.app.client_manager.identity.users + self.users_mock.reset_mock() + + # Get a shortcut to the UserManager Mock + self.groups_mock = self.app.client_manager.identity.groups + self.groups_mock.reset_mock() + + # Get a shortcut to the DomainManager Mock + self.domains_mock = self.app.client_manager.identity.domains + self.domains_mock.reset_mock() + + # Get a shortcut to the ProjectManager Mock + self.projects_mock = self.app.client_manager.identity.projects + self.projects_mock.reset_mock() + + # Get a shortcut to the RoleManager Mock + self.roles_mock = self.app.client_manager.identity.roles + self.roles_mock.reset_mock() + + +class TestRoleAdd(TestRole): + + def setUp(self): + super(TestRoleAdd, self).setUp() + + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + + self.groups_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.GROUP), + loaded=True, + ) + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + self.roles_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + self.roles_mock.grant.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + + # Get the command object to test + self.cmd = role.AddRole(self.app, None) + + def test_role_add_user_domain(self): + arglist = [ + '--user', identity_fakes.user_name, + '--domain', identity_fakes.domain_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', identity_fakes.user_name), + ('group', None), + ('domain', identity_fakes.domain_name), + ('project', None), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'user': identity_fakes.user_id, + 'domain': identity_fakes.domain_id, + } + # RoleManager.grant(role, user=, group=, domain=, project=) + self.roles_mock.grant.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_add_user_project(self): + arglist = [ + '--user', identity_fakes.user_name, + '--project', identity_fakes.project_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', identity_fakes.user_name), + ('group', None), + ('domain', None), + ('project', identity_fakes.project_name), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'user': identity_fakes.user_id, + 'project': identity_fakes.project_id, + } + # RoleManager.grant(role, user=, group=, domain=, project=) + self.roles_mock.grant.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_add_group_domain(self): + arglist = [ + '--group', identity_fakes.group_name, + '--domain', identity_fakes.domain_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', None), + ('group', identity_fakes.group_name), + ('domain', identity_fakes.domain_name), + ('project', None), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'group': identity_fakes.group_id, + 'domain': identity_fakes.domain_id, + } + # RoleManager.grant(role, user=, group=, domain=, project=) + self.roles_mock.grant.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_add_group_project(self): + arglist = [ + '--group', identity_fakes.group_name, + '--project', identity_fakes.project_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', None), + ('group', identity_fakes.group_name), + ('domain', None), + ('project', identity_fakes.project_name), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'group': identity_fakes.group_id, + 'project': identity_fakes.project_id, + } + # RoleManager.grant(role, user=, group=, domain=, project=) + self.roles_mock.grant.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + +class TestRoleCreate(TestRole): + + def setUp(self): + super(TestRoleCreate, self).setUp() + + self.roles_mock.create.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + + # Get the command object to test + self.cmd = role.CreateRole(self.app, None) + + def test_role_create_no_options(self): + arglist = [ + identity_fakes.role_name, + ] + verifylist = [ + ('name', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # RoleManager.create(name) + self.roles_mock.create.assert_called_with( + identity_fakes.role_name, + ) + + collist = ('id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.role_id, + identity_fakes.role_name, + ) + self.assertEqual(data, datalist) + + +class TestRoleDelete(TestRole): + + def setUp(self): + super(TestRoleDelete, self).setUp() + + self.roles_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + self.roles_mock.delete.return_value = None + + # Get the command object to test + self.cmd = role.DeleteRole(self.app, None) + + def test_role_delete_no_options(self): + arglist = [ + identity_fakes.role_name, + ] + verifylist = [ + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + self.roles_mock.delete.assert_called_with( + identity_fakes.role_id, + ) + + +class TestRoleList(TestRole): + + def setUp(self): + super(TestRoleList, self).setUp() + + self.roles_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ), + ] + + # Get the command object to test + self.cmd = role.ListRole(self.app, None) + + def test_role_list_no_options(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.roles_mock.list.assert_called_with() + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.role_id, + identity_fakes.role_name, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestRoleRemove(TestRole): + + def setUp(self): + super(TestRoleRemove, self).setUp() + + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + + self.groups_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.GROUP), + loaded=True, + ) + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + self.roles_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + self.roles_mock.revoke.return_value = None + + # Get the command object to test + self.cmd = role.RemoveRole(self.app, None) + + def test_role_remove_user_domain(self): + arglist = [ + '--user', identity_fakes.user_name, + '--domain', identity_fakes.domain_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', identity_fakes.user_name), + ('group', None), + ('domain', identity_fakes.domain_name), + ('project', None), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'user': identity_fakes.user_id, + 'domain': identity_fakes.domain_id, + } + # RoleManager.revoke(role, user=, group=, domain=, project=) + self.roles_mock.revoke.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_remove_user_project(self): + arglist = [ + '--user', identity_fakes.user_name, + '--project', identity_fakes.project_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', identity_fakes.user_name), + ('group', None), + ('domain', None), + ('project', identity_fakes.project_name), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'user': identity_fakes.user_id, + 'project': identity_fakes.project_id, + } + # RoleManager.revoke(role, user=, group=, domain=, project=) + self.roles_mock.revoke.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_remove_group_domain(self): + arglist = [ + '--group', identity_fakes.group_name, + '--domain', identity_fakes.domain_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', None), + ('group', identity_fakes.group_name), + ('domain', identity_fakes.domain_name), + ('project', None), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'group': identity_fakes.group_id, + 'domain': identity_fakes.domain_id, + } + # RoleManager.revoke(role, user=, group=, domain=, project=) + self.roles_mock.revoke.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + def test_role_remove_group_project(self): + arglist = [ + '--group', identity_fakes.group_name, + '--project', identity_fakes.project_name, + identity_fakes.role_name, + ] + verifylist = [ + ('user', None), + ('group', identity_fakes.group_name), + ('domain', None), + ('project', identity_fakes.project_name), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'group': identity_fakes.group_id, + 'project': identity_fakes.project_id, + } + # RoleManager.revoke(role, user=, group=, domain=, project=) + self.roles_mock.revoke.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + +class TestRoleSet(TestRole): + + def setUp(self): + super(TestRoleSet, self).setUp() + + self.roles_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + self.roles_mock.update.return_value = None + + # Get the command object to test + self.cmd = role.SetRole(self.app, None) + + def test_role_set_no_options(self): + arglist = [ + '--name', 'over', + identity_fakes.role_name, + ] + verifylist = [ + ('name', 'over'), + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'name': 'over', + } + # RoleManager.update(role, name=) + self.roles_mock.update.assert_called_with( + identity_fakes.role_id, + **kwargs + ) + + +class TestRoleShow(TestRole): + + def setUp(self): + super(TestRoleShow, self).setUp() + + self.roles_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ) + + # Get the command object to test + self.cmd = role.ShowRole(self.app, None) + + def test_service_show(self): + arglist = [ + identity_fakes.role_name, + ] + verifylist = [ + ('role', identity_fakes.role_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # RoleManager.get(role) + self.roles_mock.get.assert_called_with( + identity_fakes.role_name, + ) + + collist = ('id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.role_id, + identity_fakes.role_name, + ) + self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v3/test_service.py b/openstackclient/tests/identity/v3/test_service.py new file mode 100644 index 00000000..1c3ae21e --- /dev/null +++ b/openstackclient/tests/identity/v3/test_service.py @@ -0,0 +1,408 @@ +# Copyright 2013 Nebula Inc. +# +# 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. +# + +import copy + +from openstackclient.identity.v3 import service +from openstackclient.tests import fakes +from openstackclient.tests.identity.v3 import fakes as identity_fakes +from openstackclient.tests.identity.v3 import test_identity + + +class TestService(test_identity.TestIdentityv3): + + def setUp(self): + super(TestService, self).setUp() + + # Get a shortcut to the ServiceManager Mock + self.services_mock = self.app.client_manager.identity.services + self.services_mock.reset_mock() + + +class TestServiceCreate(TestService): + + def setUp(self): + super(TestServiceCreate, self).setUp() + + self.services_mock.create.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ) + + # Get the command object to test + self.cmd = service.CreateService(self.app, None) + + def test_service_create_name(self): + arglist = [ + '--name', identity_fakes.service_name, + identity_fakes.service_type, + ] + verifylist = [ + ('name', identity_fakes.service_name), + ('enable', False), + ('disable', False), + ('type', identity_fakes.service_type), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # ServiceManager.create(name, type, enabled=, **kwargs) + self.services_mock.create.assert_called_with( + identity_fakes.service_name, + identity_fakes.service_type, + True, + ) + + collist = ('enabled', 'id', 'name', 'type') + self.assertEqual(columns, collist) + datalist = ( + True, + identity_fakes.service_id, + identity_fakes.service_name, + identity_fakes.service_type, + ) + self.assertEqual(data, datalist) + + def test_service_create_enable(self): + arglist = [ + '--enable', + identity_fakes.service_type, + ] + verifylist = [ + ('name', None), + ('enable', True), + ('disable', False), + ('type', identity_fakes.service_type), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # ServiceManager.create(name, type, enabled=, **kwargs) + self.services_mock.create.assert_called_with( + None, + identity_fakes.service_type, + True, + ) + + collist = ('enabled', 'id', 'name', 'type') + self.assertEqual(columns, collist) + datalist = ( + True, + identity_fakes.service_id, + identity_fakes.service_name, + identity_fakes.service_type, + ) + self.assertEqual(data, datalist) + + def test_service_create_disable(self): + arglist = [ + '--disable', + identity_fakes.service_type, + ] + verifylist = [ + ('name', None), + ('enable', False), + ('disable', True), + ('type', identity_fakes.service_type), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # ServiceManager.create(name, type, enabled=, **kwargs) + self.services_mock.create.assert_called_with( + None, + identity_fakes.service_type, + False, + ) + + collist = ('enabled', 'id', 'name', 'type') + self.assertEqual(columns, collist) + datalist = ( + True, + identity_fakes.service_id, + identity_fakes.service_name, + identity_fakes.service_type, + ) + self.assertEqual(data, datalist) + + +class TestServiceDelete(TestService): + + def setUp(self): + super(TestServiceDelete, self).setUp() + + self.services_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ) + self.services_mock.delete.return_value = None + + # Get the command object to test + self.cmd = service.DeleteService(self.app, None) + + def test_service_delete_no_options(self): + arglist = [ + identity_fakes.service_name, + ] + verifylist = [ + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + self.services_mock.delete.assert_called_with( + identity_fakes.service_id, + ) + + +class TestServiceList(TestService): + + def setUp(self): + super(TestServiceList, self).setUp() + + self.services_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ), + ] + + # Get the command object to test + self.cmd = service.ListService(self.app, None) + + def test_service_list_no_options(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.services_mock.list.assert_called_with() + + collist = ('ID', 'Name', 'Type', 'Enabled') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.service_id, + identity_fakes.service_name, + identity_fakes.service_type, + True, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestServiceSet(TestService): + + def setUp(self): + super(TestServiceSet, self).setUp() + + self.services_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ) + self.services_mock.update.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ) + + # Get the command object to test + self.cmd = service.SetService(self.app, None) + + def test_service_set_no_options(self): + arglist = [ + identity_fakes.service_name, + ] + verifylist = [ + ('type', None), + ('name', None), + ('enable', False), + ('disable', False), + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + def test_service_set_type(self): + arglist = [ + '--type', identity_fakes.service_type, + identity_fakes.service_name, + ] + verifylist = [ + ('type', identity_fakes.service_type), + ('name', None), + ('enable', False), + ('disable', False), + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'name': identity_fakes.service_name, + 'type': identity_fakes.service_type, + 'enabled': True, + } + # ServiceManager.update(service, name=, type=, enabled=, **kwargs) + self.services_mock.update.assert_called_with( + identity_fakes.service_id, + **kwargs + ) + + def test_service_set_name(self): + arglist = [ + '--name', identity_fakes.service_name, + identity_fakes.service_name, + ] + verifylist = [ + ('type', None), + ('name', identity_fakes.service_name), + ('enable', False), + ('disable', False), + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'name': identity_fakes.service_name, + 'type': identity_fakes.service_type, + 'enabled': True, + } + # ServiceManager.update(service, name=, type=, enabled=, **kwargs) + self.services_mock.update.assert_called_with( + identity_fakes.service_id, + **kwargs + ) + + def test_service_set_enable(self): + arglist = [ + '--enable', + identity_fakes.service_name, + ] + verifylist = [ + ('type', None), + ('name', None), + ('enable', True), + ('disable', False), + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'name': identity_fakes.service_name, + 'type': identity_fakes.service_type, + 'enabled': True, + } + # ServiceManager.update(service, name=, type=, enabled=, **kwargs) + self.services_mock.update.assert_called_with( + identity_fakes.service_id, + **kwargs + ) + + def test_service_set_disable(self): + arglist = [ + '--disable', + identity_fakes.service_name, + ] + verifylist = [ + ('type', None), + ('name', None), + ('enable', False), + ('disable', True), + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + # Set expected values + kwargs = { + 'name': identity_fakes.service_name, + 'type': identity_fakes.service_type, + 'enabled': False, + } + # ServiceManager.update(service, name=, type=, enabled=, **kwargs) + self.services_mock.update.assert_called_with( + identity_fakes.service_id, + **kwargs + ) + + +class TestServiceShow(TestService): + + def setUp(self): + super(TestServiceShow, self).setUp() + + self.services_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.SERVICE), + loaded=True, + ) + + # Get the command object to test + self.cmd = service.ShowService(self.app, None) + + def test_service_show(self): + arglist = [ + identity_fakes.service_name, + ] + verifylist = [ + ('service', identity_fakes.service_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # ServiceManager.get(id) + self.services_mock.get.assert_called_with( + identity_fakes.service_name, + ) + + collist = ('enabled', 'id', 'name', 'type') + self.assertEqual(columns, collist) + datalist = ( + True, + identity_fakes.service_id, + identity_fakes.service_name, + identity_fakes.service_type, + ) + self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v3/test_user.py b/openstackclient/tests/identity/v3/test_user.py new file mode 100644 index 00000000..8f195805 --- /dev/null +++ b/openstackclient/tests/identity/v3/test_user.py @@ -0,0 +1,986 @@ +# Copyright 2013 Nebula Inc. +# +# 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. +# + +import copy + +from openstackclient.identity.v3 import user +from openstackclient.tests import fakes +from openstackclient.tests.identity.v3 import fakes as identity_fakes +from openstackclient.tests.identity.v3 import test_identity + + +class TestUser(test_identity.TestIdentityv3): + + def setUp(self): + super(TestUser, self).setUp() + + # Get a shortcut to the DomainManager Mock + self.domains_mock = self.app.client_manager.identity.domains + self.domains_mock.reset_mock() + + # Get a shortcut to the ProjectManager Mock + self.projects_mock = self.app.client_manager.identity.projects + self.projects_mock.reset_mock() + + # Get a shortcut to the RoleManager Mock + self.roles_mock = self.app.client_manager.identity.roles + self.roles_mock.reset_mock() + + # Get a shortcut to the UserManager Mock + self.users_mock = self.app.client_manager.identity.users + self.users_mock.reset_mock() + + +class TestUserCreate(TestUser): + + def setUp(self): + super(TestUserCreate, self).setUp() + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + self.users_mock.create.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + + # Get the command object to test + self.cmd = user.CreateUser(self.app, None) + + def test_user_create_no_options(self): + arglist = [ + identity_fakes.user_name, + ] + verifylist = [ + ('enable', False), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': None, + 'email': None, + 'enabled': True, + 'password': None, + } + + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + def test_user_create_password(self): + arglist = [ + '--password', 'secret', + identity_fakes.user_name, + ] + verifylist = [ + ('password', 'secret'), + ('enable', False), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': None, + 'email': None, + 'enabled': True, + 'password': 'secret', + } + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + def test_user_create_email(self): + arglist = [ + '--email', 'barney@example.com', + identity_fakes.user_name, + ] + verifylist = [ + ('email', 'barney@example.com'), + ('enable', False), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': None, + 'email': 'barney@example.com', + 'enabled': True, + 'password': None, + } + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + def test_user_create_project(self): + # Return the new project + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT_2), + loaded=True, + ) + # Set up to return an updated user + USER_2 = copy.deepcopy(identity_fakes.USER) + USER_2['project_id'] = identity_fakes.PROJECT_2['id'] + self.users_mock.create.return_value = fakes.FakeResource( + None, + USER_2, + loaded=True, + ) + + arglist = [ + '--project', identity_fakes.PROJECT_2['name'], + identity_fakes.user_name, + ] + verifylist = [ + ('project', identity_fakes.PROJECT_2['name']), + ('enable', False), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': identity_fakes.PROJECT_2['id'], + 'description': None, + 'domain': None, + 'email': None, + 'enabled': True, + 'password': None, + } + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.PROJECT_2['id'], + ) + self.assertEqual(data, datalist) + + def test_user_create_domain(self): + arglist = [ + '--domain', identity_fakes.domain_name, + identity_fakes.user_name, + ] + verifylist = [ + ('domain', identity_fakes.domain_name), + ('enable', False), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': identity_fakes.domain_id, + 'email': None, + 'enabled': True, + 'password': None, + } + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + def test_user_create_enable(self): + arglist = [ + '--enable', + identity_fakes.user_name, + ] + verifylist = [ + ('enable', True), + ('disable', False), + ('name', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': None, + 'email': None, + 'enabled': True, + 'password': None, + } + # UserManager.create(name, domain=, project=, password=, email=, + # description=, enabled=, default_project=) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + def test_user_create_disable(self): + arglist = [ + '--disable', + identity_fakes.user_name, + ] + verifylist = [ + ('name', identity_fakes.user_name), + ('enable', False), + ('disable', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'default_project': None, + 'description': None, + 'domain': None, + 'email': None, + 'enabled': False, + 'password': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + **kwargs + ) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) + + +class TestUserDelete(TestUser): + + def setUp(self): + super(TestUserDelete, self).setUp() + + # This is the return value for utils.find_resource() + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + self.users_mock.delete.return_value = None + + # Get the command object to test + self.cmd = user.DeleteUser(self.app, None) + + def test_user_delete_no_options(self): + arglist = [ + identity_fakes.user_id, + ] + verifylist = [ + ('user', identity_fakes.user_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + self.users_mock.delete.assert_called_with( + identity_fakes.user_id, + ) + + +class TestUserList(TestUser): + + def setUp(self): + super(TestUserList, self).setUp() + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + self.projects_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ), + ] + + self.roles_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.ROLE), + loaded=True, + ), + ] + + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + self.users_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ), + ] + + # Get the command object to test + self.cmd = user.ListUser(self.app, None) + + def test_user_list_no_options(self): + arglist = [] + verifylist = [] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.users_mock.list.assert_called_with() + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.user_id, + identity_fakes.user_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_project(self): + arglist = [ + '--project', identity_fakes.project_id, + ] + verifylist = [ + ('project', identity_fakes.project_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.users_mock.list.assert_called_with() + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.user_id, + identity_fakes.user_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_domain(self): + arglist = [ + '--domain', identity_fakes.domain_id, + ] + verifylist = [ + ('domain', identity_fakes.domain_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.users_mock.list.assert_called_with() + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.user_id, + identity_fakes.user_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_role_user(self): + arglist = [ + '--role', + identity_fakes.user_id, + ] + verifylist = [ + ('role', True), + ('user', identity_fakes.user_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'domain': 'default', + 'user': self.users_mock.get(), + } + # RoleManager.list(user=, group=, domain=, project=, **kwargs) + self.roles_mock.list.assert_called_with( + **kwargs + ) + + collist = ('ID', 'Name') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.role_id, + identity_fakes.role_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_role_domain(self): + arglist = [ + '--domain', identity_fakes.domain_name, + '--role', + identity_fakes.user_id, + ] + verifylist = [ + ('domain', identity_fakes.domain_name), + ('role', True), + ('user', identity_fakes.user_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'domain': self.domains_mock.get(), + 'user': self.users_mock.get(), + } + # RoleManager.list(user=, group=, domain=, project=, **kwargs) + self.roles_mock.list.assert_called_with( + **kwargs + ) + + collist = ('ID', 'Name', 'Domain', 'User') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.role_id, + identity_fakes.role_name, + identity_fakes.domain_name, + identity_fakes.user_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_role_project(self): + arglist = [ + '--project', identity_fakes.project_name, + '--role', + identity_fakes.user_id, + ] + verifylist = [ + ('project', identity_fakes.project_name), + ('role', True), + ('user', identity_fakes.user_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'project': self.projects_mock.get(), + 'user': self.users_mock.get(), + } + # RoleManager.list(user=, group=, domain=, project=, **kwargs) + self.roles_mock.list.assert_called_with( + **kwargs + ) + + collist = ('ID', 'Name', 'Project', 'User') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.role_id, + identity_fakes.role_name, + identity_fakes.project_name, + identity_fakes.user_name, + ), ) + self.assertEqual(tuple(data), datalist) + + def test_user_list_long(self): + arglist = [ + '--long', + ] + verifylist = [ + ('long', True), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.users_mock.list.assert_called_with() + + collist = ( + 'ID', + 'Name', + 'Project Id', + 'Domain Id', + 'Description', + 'Email', + 'Enabled', + ) + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + identity_fakes.domain_id, + '', + identity_fakes.user_email, + True, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestUserSet(TestUser): + + def setUp(self): + super(TestUserSet, self).setUp() + + self.domains_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.DOMAIN), + loaded=True, + ) + + self.projects_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + loaded=True, + ) + + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + self.users_mock.update.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + + # Get the command object to test + self.cmd = user.SetUser(self.app, None) + + def test_user_set_no_options(self): + arglist = [ + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', None), + ('domain', None), + ('project', None), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + result = self.cmd.run(parsed_args) + self.assertEqual(result, 0) + + def test_user_set_name(self): + arglist = [ + '--name', 'qwerty', + identity_fakes.user_name, + ] + verifylist = [ + ('name', 'qwerty'), + ('password', None), + ('email', None), + ('domain', None), + ('project', None), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + 'name': 'qwerty', + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_password(self): + arglist = [ + '--password', 'secret', + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', 'secret'), + ('email', None), + ('domain', None), + ('project', None), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + 'password': 'secret', + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_email(self): + arglist = [ + '--email', 'barney@example.com', + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', 'barney@example.com'), + ('domain', None), + ('project', None), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + 'email': 'barney@example.com', + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_domain(self): + arglist = [ + '--domain', identity_fakes.domain_id, + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', None), + ('domain', identity_fakes.domain_id), + ('project', None), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + 'domainId': identity_fakes.domain_id, + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_project(self): + arglist = [ + '--project', identity_fakes.project_id, + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', None), + ('domain', None), + ('project', identity_fakes.project_id), + ('enable', False), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + 'projectId': identity_fakes.project_id, + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_enable(self): + arglist = [ + '--enable', + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', None), + ('domain', None), + ('project', None), + ('enable', True), + ('disable', False), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': True, + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + def test_user_set_disable(self): + arglist = [ + '--disable', + identity_fakes.user_name, + ] + verifylist = [ + ('name', None), + ('password', None), + ('email', None), + ('domain', None), + ('project', None), + ('enable', False), + ('disable', True), + ('user', identity_fakes.user_name), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # Set expected values + kwargs = { + 'enabled': False, + } + # UserManager.update(user, name=, domain=, project=, password=, + # email=, description=, enabled=, default_project=) + self.users_mock.update.assert_called_with( + identity_fakes.user_id, + **kwargs + ) + + +class TestUserShow(TestUser): + + def setUp(self): + super(TestUserShow, self).setUp() + + self.users_mock.get.return_value = fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.USER), + loaded=True, + ) + + # Get the command object to test + self.cmd = user.ShowUser(self.app, None) + + def test_user_show(self): + arglist = [ + identity_fakes.user_id, + ] + verifylist = [ + ('user', identity_fakes.user_id), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + columns, data = self.cmd.take_action(parsed_args) + + self.users_mock.get.assert_called_with(identity_fakes.user_id) + + collist = ('domain_id', 'email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.domain_id, + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) |