From eb405a88c47e91633ecb110122410aa24c24f9cd Mon Sep 17 00:00:00 2001 From: Dean Troyer Date: Wed, 28 Aug 2013 15:17:45 -0500 Subject: Refactor fake data for projects and users * Move fake data structures into tests/identity/fakes.py * Use fake clients correctly and support multiple client versions Change-Id: Icacbb2ca740b63937bd2c4442af61b620638b53e --- openstackclient/tests/fakes.py | 6 +- openstackclient/tests/identity/fakes.py | 36 +- openstackclient/tests/identity/test_identity.py | 30 +- .../tests/identity/v2_0/test_project.py | 452 +++++++++++++++ .../tests/identity/v2_0/test_projects.py | 355 ------------ openstackclient/tests/identity/v2_0/test_user.py | 623 +++++++++++++++++++++ openstackclient/tests/identity/v2_0/test_users.py | 496 ---------------- .../tests/object/v1/lib/test_container.py | 2 + openstackclient/tests/object/v1/lib/test_object.py | 2 + openstackclient/tests/utils.py | 2 - 10 files changed, 1130 insertions(+), 874 deletions(-) create mode 100644 openstackclient/tests/identity/v2_0/test_project.py delete mode 100644 openstackclient/tests/identity/v2_0/test_projects.py create mode 100644 openstackclient/tests/identity/v2_0/test_user.py delete mode 100644 openstackclient/tests/identity/v2_0/test_users.py (limited to 'openstackclient') diff --git a/openstackclient/tests/fakes.py b/openstackclient/tests/fakes.py index e0122022..22292a64 100644 --- a/openstackclient/tests/fakes.py +++ b/openstackclient/tests/fakes.py @@ -37,6 +37,7 @@ class FakeApp(object): self.stdin = sys.stdin self.stdout = _stdout or sys.stdout self.stderr = sys.stderr + self.restapi = None class FakeClientManager(object): @@ -44,11 +45,6 @@ class FakeClientManager(object): pass -class FakeRESTApi(object): - def __init__(self): - pass - - class FakeResource(object): def __init__(self, manager, info, loaded=False): self.manager = manager diff --git a/openstackclient/tests/identity/fakes.py b/openstackclient/tests/identity/fakes.py index b1e385e2..1c1ea72b 100644 --- a/openstackclient/tests/identity/fakes.py +++ b/openstackclient/tests/identity/fakes.py @@ -18,6 +18,38 @@ import mock from openstackclient.tests import fakes +user_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' +user_name = 'paul' +user_description = 'Sir Paul' +user_email = 'paul@applecorps.com' + +project_id = '8-9-64' +project_name = 'beatles' +project_description = 'Fab Four' + +USER = { + 'id': user_id, + 'name': user_name, + 'tenantId': project_id, + 'email': user_email, + 'enabled': True, +} + +PROJECT = { + 'id': project_id, + 'name': project_name, + 'description': project_description, + 'enabled': True, +} + +PROJECT_2 = { + 'id': project_id + '-2222', + 'name': project_name + ' reprise', + 'description': project_description + 'plus four more', + 'enabled': True, +} + + class FakeIdentityv2Client(object): def __init__(self, **kwargs): self.tenants = mock.Mock() @@ -26,8 +58,8 @@ class FakeIdentityv2Client(object): self.users.resource_class = fakes.FakeResource(None, {}) self.ec2 = mock.Mock() self.ec2.resource_class = fakes.FakeResource(None, {}) - self.auth_tenant_id = 'fake-tenant' - self.auth_user_id = 'fake-user' + self.auth_token = kwargs['token'] + self.management_url = kwargs['endpoint'] class FakeIdentityv3Client(object): diff --git a/openstackclient/tests/identity/test_identity.py b/openstackclient/tests/identity/test_identity.py index 04bbd20f..894f47ba 100644 --- a/openstackclient/tests/identity/test_identity.py +++ b/openstackclient/tests/identity/test_identity.py @@ -22,27 +22,29 @@ AUTH_TOKEN = "foobar" AUTH_URL = "http://0.0.0.0" -class FakeClient(object): - def __init__(self, endpoint=None, **kwargs): - self.auth_token = AUTH_TOKEN - self.auth_url = AUTH_URL - - -class TestIdentity(utils.TestCase): +class TestIdentity(utils.TestCommand): def setUp(self): super(TestIdentity, self).setUp() api_version = {"identity": "2.0"} identity_client.API_VERSIONS = { - "2.0": "openstackclient.tests.identity.test_identity.FakeClient" + "2.0": "openstackclient.tests.identity.fakes.FakeIdentityv2Client" } - self.cm = clientmanager.ClientManager(token=AUTH_TOKEN, - url=AUTH_URL, - auth_url=AUTH_URL, - api_version=api_version) + self.app.client_manager = clientmanager.ClientManager( + token=AUTH_TOKEN, + url=AUTH_URL, + auth_url=AUTH_URL, + api_version=api_version, + ) def test_make_client(self): - self.assertEqual(self.cm.identity.auth_token, AUTH_TOKEN) - self.assertEqual(self.cm.identity.auth_url, AUTH_URL) + self.assertEqual( + self.app.client_manager.identity.auth_token, + AUTH_TOKEN, + ) + self.assertEqual( + self.app.client_manager.identity.management_url, + AUTH_URL, + ) diff --git a/openstackclient/tests/identity/v2_0/test_project.py b/openstackclient/tests/identity/v2_0/test_project.py new file mode 100644 index 00000000..c6c9b8ee --- /dev/null +++ b/openstackclient/tests/identity/v2_0/test_project.py @@ -0,0 +1,452 @@ +# 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.v2_0 import project +from openstackclient.tests import fakes +from openstackclient.tests.identity import fakes as identity_fakes +from openstackclient.tests.identity import test_identity + + +class TestProject(test_identity.TestIdentity): + + def setUp(self): + super(TestProject, self).setUp() + + # Get a shortcut to the TenantManager Mock + self.projects_mock = self.app.client_manager.identity.tenants + self.projects_mock.reset_mock() + + +class TestProjectCreate(TestProject): + + def setUp(self): + super(TestProjectCreate, self).setUp() + + 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 = [ + ('project_name', identity_fakes.project_name), + ('enable', False), + ('disable', False), + ] + 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, + } + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + **kwargs + ) + + collist = ('description', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + 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 = [ + ('project_name', identity_fakes.project_name), + ('description', 'new desc'), + ] + 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, + } + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + **kwargs + ) + + collist = ('description', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + 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 = [ + ('project_name', identity_fakes.project_name), + ('enable', True), + ('disable', False), + ] + 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, + } + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + **kwargs + ) + + collist = ('description', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + 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 = [ + ('project_name', identity_fakes.project_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 = { + 'description': None, + 'enabled': False, + } + self.projects_mock.create.assert_called_with( + identity_fakes.project_name, + **kwargs + ) + + collist = ('description', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + 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', 'Description', 'Enabled') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.project_id, + identity_fakes.project_name, + identity_fakes.project_description, + True, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestProjectSet(TestProject): + + def setUp(self): + super(TestProjectSet, 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.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) + + # Set expected values + kwargs = { + 'description': identity_fakes.project_description, + 'enabled': True, + 'tenant_name': identity_fakes.project_name, + } + self.projects_mock.update.assert_called_with( + identity_fakes.project_id, + **kwargs + ) + + def test_project_set_name(self): + arglist = [ + '--name', 'qwerty', + identity_fakes.project_name, + ] + verifylist = [ + ('name', 'qwerty'), + ] + 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, + 'enabled': True, + 'tenant_name': 'qwerty', + } + 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'), + ] + 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', + 'enabled': True, + 'tenant_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), + ] + 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, + 'enabled': True, + 'tenant_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), + ] + 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, + 'enabled': False, + 'tenant_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', 'enabled', 'id', 'name') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.project_description, + True, + identity_fakes.project_id, + identity_fakes.project_name, + ) + self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v2_0/test_projects.py b/openstackclient/tests/identity/v2_0/test_projects.py deleted file mode 100644 index c937028f..00000000 --- a/openstackclient/tests/identity/v2_0/test_projects.py +++ /dev/null @@ -1,355 +0,0 @@ -# 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.v2_0 import project -from openstackclient.tests import fakes -from openstackclient.tests.identity import fakes as identity_fakes -from openstackclient.tests import utils - - -IDENTITY_API_VERSION = "2.0" - -user_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' -user_name = 'paul' -user_description = 'Sir Paul' - -project_id = '8-9-64' -project_name = 'beatles' -project_description = 'Fab Four' - -USER = { - 'id': user_id, - 'name': user_name, - 'tenantId': project_id, -} - -PROJECT = { - 'id': project_id, - 'name': project_name, - 'description': project_description, - 'enabled': True, -} - - -class TestProject(utils.TestCommand): - - def setUp(self): - super(TestProject, self).setUp() - self.app.client_manager.identity = \ - identity_fakes.FakeIdentityv2Client() - - # Get a shortcut to the TenantManager Mock - self.projects_mock = self.app.client_manager.identity.tenants - - -class TestProjectCreate(TestProject): - - def setUp(self): - super(TestProjectCreate, self).setUp() - - self.projects_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(PROJECT), - loaded=True, - ) - - # Get the command object to test - self.cmd = project.CreateProject(self.app, None) - - def test_project_create_no_options(self): - arglist = [project_name] - verifylist = [ - ('project_name', project_name), - ('enable', False), - ('disable', False), - ] - 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, - } - self.projects_mock.create.assert_called_with(project_name, **kwargs) - - collist = ('description', 'enabled', 'id', 'name') - self.assertEqual(columns, collist) - datalist = (project_description, True, project_id, project_name) - self.assertEqual(data, datalist) - - def test_project_create_description(self): - arglist = ['--description', 'new desc', project_name] - verifylist = [('description', 'new desc')] - 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, - } - self.projects_mock.create.assert_called_with(project_name, **kwargs) - - collist = ('description', 'enabled', 'id', 'name') - self.assertEqual(columns, collist) - datalist = (project_description, True, project_id, project_name) - self.assertEqual(data, datalist) - - def test_project_create_enable(self): - arglist = ['--enable', project_name] - verifylist = [('enable', True), ('disable', False)] - 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, - } - self.projects_mock.create.assert_called_with(project_name, **kwargs) - - collist = ('description', 'enabled', 'id', 'name') - self.assertEqual(columns, collist) - datalist = (project_description, True, project_id, project_name) - self.assertEqual(data, datalist) - - def test_project_create_disable(self): - arglist = ['--disable', project_name] - verifylist = [('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 = { - 'description': None, - 'enabled': False, - } - self.projects_mock.create.assert_called_with(project_name, **kwargs) - - collist = ('description', 'enabled', 'id', 'name') - self.assertEqual(columns, collist) - datalist = (project_description, True, project_id, 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(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 = [user_id] - verifylist = [('project', user_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(project_id) - - -class TestProjectList(TestProject): - - def setUp(self): - super(TestProjectList, self).setUp() - - self.projects_mock.list.return_value = [ - fakes.FakeResource( - None, - copy.deepcopy(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 = ((project_id, 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', 'Description', 'Enabled') - self.assertEqual(columns, collist) - datalist = ((project_id, project_name, project_description, True), ) - self.assertEqual(tuple(data), datalist) - - -class TestProjectSet(TestProject): - - def setUp(self): - super(TestProjectSet, self).setUp() - - self.projects_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(PROJECT), - loaded=True, - ) - - # Get the command object to test - self.cmd = project.SetProject(self.app, None) - - def test_project_set_no_options(self): - arglist = [project_name] - verifylist = [ - ('project', 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) - - # Set expected values - kwargs = { - 'description': project_description, - 'enabled': True, - 'tenant_name': project_name, - } - self.projects_mock.update.assert_called_with(project_id, **kwargs) - - def test_project_set_name(self): - arglist = ['--name', 'qwerty', project_name] - verifylist = [('name', 'qwerty')] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - result = self.cmd.run(parsed_args) - self.assertEqual(result, 0) - - # Set expected values - kwargs = { - 'description': project_description, - 'enabled': True, - 'tenant_name': 'qwerty', - } - self.projects_mock.update.assert_called_with(project_id, **kwargs) - - def test_project_set_description(self): - arglist = ['--description', 'new desc', project_name] - verifylist = [('description', 'new desc')] - 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', - 'enabled': True, - 'tenant_name': project_name, - } - self.projects_mock.update.assert_called_with(project_id, **kwargs) - - def test_project_set_enable(self): - arglist = ['--enable', project_name] - verifylist = [('enable', True), ('disable', False)] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - result = self.cmd.run(parsed_args) - self.assertEqual(result, 0) - - # Set expected values - kwargs = { - 'description': project_description, - 'enabled': True, - 'tenant_name': project_name, - } - self.projects_mock.update.assert_called_with(project_id, **kwargs) - - def test_project_set_disable(self): - arglist = ['--disable', project_name] - verifylist = [('enable', False), ('disable', True)] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - result = self.cmd.run(parsed_args) - self.assertEqual(result, 0) - - # Set expected values - kwargs = { - 'description': project_description, - 'enabled': False, - 'tenant_name': project_name, - } - self.projects_mock.update.assert_called_with(project_id, **kwargs) - - -class TestProjectShow(TestProject): - - def setUp(self): - super(TestProjectShow, self).setUp() - - self.projects_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(PROJECT), - loaded=True, - ) - - # Get the command object to test - self.cmd = project.ShowProject(self.app, None) - - def test_project_show(self): - arglist = [user_id] - verifylist = [('project', 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.projects_mock.get.assert_called_with(user_id) - - collist = ('description', 'enabled', 'id', 'name') - self.assertEqual(columns, collist) - datalist = (project_description, True, project_id, project_name) - self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v2_0/test_user.py b/openstackclient/tests/identity/v2_0/test_user.py new file mode 100644 index 00000000..529173da --- /dev/null +++ b/openstackclient/tests/identity/v2_0/test_user.py @@ -0,0 +1,623 @@ +# 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.v2_0 import user +from openstackclient.tests import fakes +from openstackclient.tests.identity import fakes as identity_fakes +from openstackclient.tests.identity import test_identity + + +class TestUser(test_identity.TestIdentity): + + def setUp(self): + super(TestUser, self).setUp() + + # 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() + + +class TestUserCreate(TestUser): + + def setUp(self): + super(TestUserCreate, self).setUp() + + 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 = [ + ('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 = { + 'enabled': True, + 'tenant_id': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + None, + None, + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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 = [ + ('name', identity_fakes.user_name), + ('password', 'secret') + ] + 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 = { + 'enabled': True, + 'tenant_id': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + 'secret', + None, + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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 = [ + ('name', identity_fakes.user_name), + ('email', 'barney@example.com'), + ] + 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 = { + 'enabled': True, + 'tenant_id': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + None, + 'barney@example.com', + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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['tenantId'] = 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 = [ + ('name', identity_fakes.user_name), + ('project', identity_fakes.PROJECT_2['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 = { + 'enabled': True, + 'tenant_id': identity_fakes.PROJECT_2['id'], + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + None, + None, + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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_enable(self): + arglist = [ + '--enable', + identity_fakes.user_name, + ] + verifylist = [ + ('name', identity_fakes.user_name), + ('enable', True), + ('disable', False), + ] + 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 = { + 'enabled': True, + 'tenant_id': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + None, + None, + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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 = { + 'enabled': False, + 'tenant_id': None, + } + # users.create(name, password, email, tenant_id=None, enabled=True) + self.users_mock.create.assert_called_with( + identity_fakes.user_name, + None, + None, + **kwargs + ) + + collist = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + 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.projects_mock.list.return_value = [ + fakes.FakeResource( + None, + copy.deepcopy(identity_fakes.PROJECT), + 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_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', 'Email', 'Enabled') + self.assertEqual(columns, collist) + datalist = (( + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_name, + identity_fakes.user_email, + True, + ), ) + self.assertEqual(tuple(data), datalist) + + +class TestUserSet(TestUser): + + def setUp(self): + super(TestUserSet, self).setUp() + + 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, + ) + + # 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 = [ + ('user', identity_fakes.user_name), + ('enable', False), + ('disable', False), + ('project', None), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + # SetUser doesn't call anything if no args are passed + self.assertFalse(self.users_mock.update.called) + + def test_user_set_name(self): + arglist = [ + '--name', 'qwerty', + identity_fakes.user_name, + ] + verifylist = [ + ('name', 'qwerty'), + ] + 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': 'qwerty', + } + 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 = [ + ('password', 'secret'), + ] + parsed_args = self.check_parser(self.cmd, arglist, verifylist) + + # DisplayCommandBase.take_action() returns two tuples + self.cmd.take_action(parsed_args) + + self.users_mock.update_password.assert_called_with( + identity_fakes.user_id, + 'secret', + ) + + def test_user_set_email(self): + arglist = [ + '--email', 'barney@example.com', + identity_fakes.user_name, + ] + verifylist = [ + ('email', 'barney@example.com'), + ] + 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 = { + 'email': 'barney@example.com', + } + 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 = [ + ('project', identity_fakes.project_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.update_tenant.assert_called_with( + identity_fakes.user_id, + identity_fakes.project_id, + ) + + def test_user_set_enable(self): + arglist = [ + '--enable', + identity_fakes.user_name, + ] + verifylist = [ + ('enable', True), + ('disable', False), + ] + 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, + } + 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 = [ + ('enable', False), + ('disable', True), + ] + 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, + } + 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 = ('email', 'enabled', 'id', 'name', 'project_id') + self.assertEqual(columns, collist) + datalist = ( + identity_fakes.user_email, + True, + identity_fakes.user_id, + identity_fakes.user_name, + identity_fakes.project_id, + ) + self.assertEqual(data, datalist) diff --git a/openstackclient/tests/identity/v2_0/test_users.py b/openstackclient/tests/identity/v2_0/test_users.py deleted file mode 100644 index 49a5262b..00000000 --- a/openstackclient/tests/identity/v2_0/test_users.py +++ /dev/null @@ -1,496 +0,0 @@ -# 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.v2_0 import user -from openstackclient.tests import fakes -from openstackclient.tests.identity import fakes as identity_fakes -from openstackclient.tests import utils - - -IDENTITY_API_VERSION = "2.0" - -user_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' -user_name = 'paul' -user_description = 'Sir Paul' -user_email = 'paul@applecorps.com' - -project_id = '8-9-64' -project_name = 'beatles' -project_description = 'Fab Four' - -USER = { - 'id': user_id, - 'name': user_name, - 'tenantId': project_id, - 'email': user_email, - 'enabled': True, -} - -PROJECT = { - 'id': project_id, - 'name': project_name, - 'description': project_description, - 'enabled': True, -} - -PROJECT_2 = { - 'id': project_id + '-2222', - 'name': project_name + ' reprise', - 'description': project_description + 'plus four more', - 'enabled': True, -} - - -class TestUser(utils.TestCommand): - - def setUp(self): - super(TestUser, self).setUp() - self.app.client_manager.identity = \ - identity_fakes.FakeIdentityv2Client() - - # Get a shortcut to the TenantManager Mock - self.projects_mock = self.app.client_manager.identity.tenants - # Get a shortcut to the UserManager Mock - self.users_mock = self.app.client_manager.identity.users - - -class TestUserCreate(TestUser): - - def setUp(self): - super(TestUserCreate, self).setUp() - - self.projects_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(PROJECT), - loaded=True, - ) - self.users_mock.create.return_value = fakes.FakeResource( - None, - copy.deepcopy(USER), - loaded=True, - ) - - # Get the command object to test - self.cmd = user.CreateUser(self.app, None) - - def test_user_create_no_options(self): - arglist = [user_name] - verifylist = [ - ('name', 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 = { - 'enabled': True, - 'tenant_id': None, - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - user_name, - None, - None, - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, project_id) - self.assertEqual(data, datalist) - - def test_user_create_password(self): - arglist = ['--password', 'secret', user_name] - verifylist = [('password', 'secret')] - 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 = { - 'enabled': True, - 'tenant_id': None, - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - user_name, - 'secret', - None, - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, project_id) - self.assertEqual(data, datalist) - - def test_user_create_email(self): - arglist = ['--email', 'barney@example.com', user_name] - verifylist = [('email', 'barney@example.com')] - 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 = { - 'enabled': True, - 'tenant_id': None, - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - user_name, - None, - 'barney@example.com', - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, 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(PROJECT_2), - loaded=True, - ) - # Set up to return an updated user - USER_2 = copy.deepcopy(USER) - USER_2['tenantId'] = PROJECT_2['id'] - self.users_mock.create.return_value = fakes.FakeResource( - None, - USER_2, - loaded=True, - ) - - arglist = ['--project', PROJECT_2['name'], user_name] - verifylist = [('project', PROJECT_2['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 = { - 'enabled': True, - 'tenant_id': PROJECT_2['id'], - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - user_name, - None, - None, - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, PROJECT_2['id']) - self.assertEqual(data, datalist) - - def test_user_create_enable(self): - arglist = ['--enable', project_name] - verifylist = [('enable', True), ('disable', False)] - 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 = { - 'enabled': True, - 'tenant_id': None, - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - project_name, - None, - None, - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, project_id) - self.assertEqual(data, datalist) - - def test_user_create_disable(self): - arglist = ['--disable', project_name] - verifylist = [('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 = { - 'enabled': False, - 'tenant_id': None, - } - # users.create(name, password, email, tenant_id=None, enabled=True) - self.users_mock.create.assert_called_with( - project_name, - None, - None, - **kwargs - ) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, 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(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 = [user_id] - verifylist = [ - ('user', 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(user_id) - - -class TestUserList(TestUser): - - def setUp(self): - super(TestUserList, self).setUp() - - self.users_mock.list.return_value = [ - fakes.FakeResource( - None, - copy.deepcopy(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 = ((user_id, user_name), ) - self.assertEqual(tuple(data), datalist) - - def test_user_list_project(self): - arglist = ['--project', project_id] - verifylist = [('project', 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 = ((user_id, 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', 'Email', 'Enabled') - self.assertEqual(columns, collist) - datalist = ((user_id, user_name, project_id, user_email, True), ) - self.assertEqual(tuple(data), datalist) - - -class TestUserSet(TestUser): - - def setUp(self): - super(TestUserSet, self).setUp() - - self.projects_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(PROJECT), - loaded=True, - ) - self.users_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(USER), - loaded=True, - ) - - # Get the command object to test - self.cmd = user.SetUser(self.app, None) - - def test_user_set_no_options(self): - arglist = [user_name] - verifylist = [ - ('user', user_name), - ('enable', False), - ('disable', False), - ('project', None), - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - # DisplayCommandBase.take_action() returns two tuples - self.cmd.take_action(parsed_args) - - self.assertFalse(self.users_mock.update.called) - - def test_user_set_name(self): - arglist = ['--name', 'qwerty', user_name] - verifylist = [('name', 'qwerty')] - 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': 'qwerty', - } - self.users_mock.update.assert_called_with(user_id, **kwargs) - - def test_user_set_password(self): - arglist = ['--password', 'secret', user_name] - verifylist = [('password', 'secret')] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - # DisplayCommandBase.take_action() returns two tuples - self.cmd.take_action(parsed_args) - - self.users_mock.update_password.assert_called_with(user_id, 'secret') - - def test_user_set_email(self): - arglist = ['--email', 'barney@example.com', user_name] - verifylist = [('email', 'barney@example.com')] - 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 = { - 'email': 'barney@example.com', - } - self.users_mock.update.assert_called_with(user_id, **kwargs) - - def test_user_set_project(self): - arglist = ['--project', project_id, user_name] - verifylist = [('project', project_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.update_tenant.assert_called_with( - user_id, - project_id, - ) - - def test_user_set_enable(self): - arglist = ['--enable', user_name] - verifylist = [('enable', True), ('disable', False)] - 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, - } - self.users_mock.update.assert_called_with(user_id, **kwargs) - - def test_user_set_disable(self): - arglist = ['--disable', user_name] - verifylist = [('enable', False), ('disable', True)] - 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, - } - self.users_mock.update.assert_called_with(user_id, **kwargs) - - -class TestUserShow(TestUser): - - def setUp(self): - super(TestUserShow, self).setUp() - - self.users_mock.get.return_value = fakes.FakeResource( - None, - copy.deepcopy(USER), - loaded=True, - ) - - # Get the command object to test - self.cmd = user.ShowUser(self.app, None) - - def test_user_show(self): - arglist = [user_id] - verifylist = [('user', 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(user_id) - - collist = ('email', 'enabled', 'id', 'name', 'project_id') - self.assertEqual(columns, collist) - datalist = (user_email, True, user_id, user_name, project_id) - self.assertEqual(data, datalist) diff --git a/openstackclient/tests/object/v1/lib/test_container.py b/openstackclient/tests/object/v1/lib/test_container.py index a241cc02..1c0112c8 100644 --- a/openstackclient/tests/object/v1/lib/test_container.py +++ b/openstackclient/tests/object/v1/lib/test_container.py @@ -22,6 +22,7 @@ import mock from openstackclient.object.v1.lib import container as lib_container from openstackclient.tests.common import test_restapi as restapi +from openstackclient.tests import fakes from openstackclient.tests import utils @@ -41,6 +42,7 @@ class TestObject(utils.TestCommand): def setUp(self): super(TestObject, self).setUp() + self.app.client_manager = fakes.FakeClientManager() self.app.client_manager.object = FakeClient() self.app.restapi = mock.MagicMock() diff --git a/openstackclient/tests/object/v1/lib/test_object.py b/openstackclient/tests/object/v1/lib/test_object.py index ef8ae18d..b4793cc2 100644 --- a/openstackclient/tests/object/v1/lib/test_object.py +++ b/openstackclient/tests/object/v1/lib/test_object.py @@ -21,6 +21,7 @@ import mock from openstackclient.object.v1.lib import object as lib_object from openstackclient.tests.common import test_restapi as restapi +from openstackclient.tests import fakes from openstackclient.tests import utils @@ -40,6 +41,7 @@ class TestObject(utils.TestCommand): def setUp(self): super(TestObject, self).setUp() + self.app.client_manager = fakes.FakeClientManager() self.app.client_manager.object = FakeClient() self.app.restapi = mock.MagicMock() diff --git a/openstackclient/tests/utils.py b/openstackclient/tests/utils.py index 45163189..cf7fda6d 100644 --- a/openstackclient/tests/utils.py +++ b/openstackclient/tests/utils.py @@ -70,8 +70,6 @@ class TestCommand(TestCase): # Build up a fake app self.fake_stdout = fakes.FakeStdout() self.app = fakes.FakeApp(self.fake_stdout) - self.app.client_manager = fakes.FakeClientManager() - self.app.restapi = fakes.FakeRESTApi() def check_parser(self, cmd, args, verify_args): cmd_parser = cmd.get_parser('check_parser') -- cgit v1.2.1