39839def2e
this will better isolate the unit tests from the functional tests. unfortunately, the "integration" tests had to be lumped into the "unit" tests since we need the separation in testr.conf Change-Id: Ifd12198c1f90e4e3c951c73bfa1884ab300d8ded
358 lines
11 KiB
Python
358 lines
11 KiB
Python
# 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 mock import call
|
|
|
|
from osc_lib import exceptions
|
|
|
|
from openstackclient.identity.v3 import credential
|
|
from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
|
|
from openstackclient.tests.unit import utils
|
|
|
|
|
|
class TestCredential(identity_fakes.TestIdentityv3):
|
|
|
|
def setUp(self):
|
|
super(TestCredential, self).setUp()
|
|
|
|
# Get a shortcut to the CredentialManager Mock
|
|
self.credentials_mock = self.app.client_manager.identity.credentials
|
|
self.credentials_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 ProjectManager Mock
|
|
self.projects_mock = self.app.client_manager.identity.projects
|
|
self.projects_mock.reset_mock()
|
|
|
|
|
|
class TestCredentialCreate(TestCredential):
|
|
|
|
user = identity_fakes.FakeUser.create_one_user()
|
|
project = identity_fakes.FakeProject.create_one_project()
|
|
columns = (
|
|
'blob',
|
|
'id',
|
|
'project_id',
|
|
'type',
|
|
'user_id',
|
|
)
|
|
|
|
def setUp(self):
|
|
super(TestCredentialCreate, self).setUp()
|
|
|
|
self.credential = identity_fakes.FakeCredential.create_one_credential(
|
|
attrs={'user_id': self.user.id, 'project_id': self.project.id})
|
|
self.credentials_mock.create.return_value = self.credential
|
|
self.users_mock.get.return_value = self.user
|
|
self.projects_mock.get.return_value = self.project
|
|
self.data = (
|
|
self.credential.blob,
|
|
self.credential.id,
|
|
self.credential.project_id,
|
|
self.credential.type,
|
|
self.credential.user_id,
|
|
)
|
|
|
|
self.cmd = credential.CreateCredential(self.app, None)
|
|
|
|
def test_credential_create_no_options(self):
|
|
arglist = [
|
|
self.credential.user_id,
|
|
self.credential.blob,
|
|
]
|
|
verifylist = [
|
|
('user', self.credential.user_id),
|
|
('data', self.credential.blob),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
|
|
kwargs = {
|
|
'user': self.credential.user_id,
|
|
'type': self.credential.type,
|
|
'blob': self.credential.blob,
|
|
'project': None,
|
|
}
|
|
self.credentials_mock.create.assert_called_once_with(
|
|
**kwargs
|
|
)
|
|
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, data)
|
|
|
|
def test_credential_create_with_options(self):
|
|
arglist = [
|
|
self.credential.user_id,
|
|
self.credential.blob,
|
|
'--type', self.credential.type,
|
|
'--project', self.credential.project_id,
|
|
]
|
|
verifylist = [
|
|
('user', self.credential.user_id),
|
|
('data', self.credential.blob),
|
|
('type', self.credential.type),
|
|
('project', self.credential.project_id),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
|
|
kwargs = {
|
|
'user': self.credential.user_id,
|
|
'type': self.credential.type,
|
|
'blob': self.credential.blob,
|
|
'project': self.credential.project_id,
|
|
}
|
|
self.credentials_mock.create.assert_called_once_with(
|
|
**kwargs
|
|
)
|
|
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, data)
|
|
|
|
def test_credential_create_with_invalid_type(self):
|
|
arglist = [
|
|
self.credential.user_id,
|
|
self.credential.blob,
|
|
'--type', 'invalid_type',
|
|
]
|
|
verifylist = [
|
|
('user', self.credential.user_id),
|
|
('data', self.credential.blob),
|
|
('type', 'invalid_type'),
|
|
]
|
|
self.assertRaises(utils.ParserException, self.check_parser,
|
|
self.cmd, arglist, verifylist)
|
|
|
|
|
|
class TestCredentialDelete(TestCredential):
|
|
|
|
credentials = identity_fakes.FakeCredential.create_credentials(count=2)
|
|
|
|
def setUp(self):
|
|
super(TestCredentialDelete, self).setUp()
|
|
|
|
self.credentials_mock.delete.return_value = None
|
|
|
|
# Get the command object to test
|
|
self.cmd = credential.DeleteCredential(self.app, None)
|
|
|
|
def test_credential_delete(self):
|
|
arglist = [
|
|
self.credentials[0].id,
|
|
]
|
|
verifylist = [
|
|
('credential', [self.credentials[0].id]),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
result = self.cmd.take_action(parsed_args)
|
|
|
|
self.credentials_mock.delete.assert_called_with(
|
|
self.credentials[0].id,
|
|
)
|
|
self.assertIsNone(result)
|
|
|
|
def test_credential_multi_delete(self):
|
|
arglist = []
|
|
for c in self.credentials:
|
|
arglist.append(c.id)
|
|
verifylist = [
|
|
('credential', arglist),
|
|
]
|
|
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
result = self.cmd.take_action(parsed_args)
|
|
|
|
calls = []
|
|
for c in self.credentials:
|
|
calls.append(call(c.id))
|
|
self.credentials_mock.delete.assert_has_calls(calls)
|
|
self.assertIsNone(result)
|
|
|
|
def test_credential_multi_delete_with_exception(self):
|
|
arglist = [
|
|
self.credentials[0].id,
|
|
'unexist_credential',
|
|
]
|
|
verifylist = [
|
|
('credential', [self.credentials[0].id, 'unexist_credential'])
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
delete_mock_result = [None, exceptions.CommandError]
|
|
self.credentials_mock.delete = (
|
|
mock.MagicMock(side_effect=delete_mock_result)
|
|
)
|
|
|
|
try:
|
|
self.cmd.take_action(parsed_args)
|
|
self.fail('CommandError should be raised.')
|
|
except exceptions.CommandError as e:
|
|
self.assertEqual('1 of 2 credential failed to delete.', str(e))
|
|
|
|
self.credentials_mock.delete.assert_any_call(self.credentials[0].id)
|
|
self.credentials_mock.delete.assert_any_call('unexist_credential')
|
|
|
|
|
|
class TestCredentialList(TestCredential):
|
|
|
|
credential = identity_fakes.FakeCredential.create_one_credential()
|
|
|
|
columns = ('ID', 'Type', 'User ID', 'Data', 'Project ID')
|
|
data = ((
|
|
credential.id,
|
|
credential.type,
|
|
credential.user_id,
|
|
credential.blob,
|
|
credential.project_id,
|
|
), )
|
|
|
|
def setUp(self):
|
|
super(TestCredentialList, self).setUp()
|
|
|
|
self.credentials_mock.list.return_value = [self.credential]
|
|
|
|
# Get the command object to test
|
|
self.cmd = credential.ListCredential(self.app, None)
|
|
|
|
def test_domain_list_no_options(self):
|
|
arglist = []
|
|
verifylist = []
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
|
|
self.credentials_mock.list.assert_called_with()
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, tuple(data))
|
|
|
|
|
|
class TestCredentialSet(TestCredential):
|
|
|
|
credential = identity_fakes.FakeCredential.create_one_credential()
|
|
|
|
def setUp(self):
|
|
super(TestCredentialSet, self).setUp()
|
|
self.cmd = credential.SetCredential(self.app, None)
|
|
|
|
def test_credential_set_no_options(self):
|
|
arglist = [
|
|
self.credential.id,
|
|
]
|
|
|
|
self.assertRaises(utils.ParserException,
|
|
self.check_parser, self.cmd, arglist, [])
|
|
|
|
def test_credential_set_missing_user(self):
|
|
arglist = [
|
|
'--type', 'ec2',
|
|
'--data', self.credential.blob,
|
|
self.credential.id,
|
|
]
|
|
|
|
self.assertRaises(utils.ParserException,
|
|
self.check_parser, self.cmd, arglist, [])
|
|
|
|
def test_credential_set_missing_type(self):
|
|
arglist = [
|
|
'--user', self.credential.user_id,
|
|
'--data', self.credential.blob,
|
|
self.credential.id,
|
|
]
|
|
|
|
self.assertRaises(utils.ParserException,
|
|
self.check_parser, self.cmd, arglist, [])
|
|
|
|
def test_credential_set_missing_data(self):
|
|
arglist = [
|
|
'--user', self.credential.user_id,
|
|
'--type', 'ec2',
|
|
self.credential.id,
|
|
]
|
|
|
|
self.assertRaises(utils.ParserException,
|
|
self.check_parser, self.cmd, arglist, [])
|
|
|
|
def test_credential_set_valid(self):
|
|
arglist = [
|
|
'--user', self.credential.user_id,
|
|
'--type', 'ec2',
|
|
'--data', self.credential.blob,
|
|
self.credential.id,
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, [])
|
|
|
|
result = self.cmd.take_action(parsed_args)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
def test_credential_set_valid_with_project(self):
|
|
arglist = [
|
|
'--user', self.credential.user_id,
|
|
'--type', 'ec2',
|
|
'--data', self.credential.blob,
|
|
'--project', self.credential.project_id,
|
|
self.credential.id,
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, [])
|
|
|
|
result = self.cmd.take_action(parsed_args)
|
|
|
|
self.assertIsNone(result)
|
|
|
|
|
|
class TestCredentialShow(TestCredential):
|
|
|
|
columns = (
|
|
'blob',
|
|
'id',
|
|
'project_id',
|
|
'type',
|
|
'user_id',
|
|
)
|
|
|
|
def setUp(self):
|
|
super(TestCredentialShow, self).setUp()
|
|
|
|
self.credential = identity_fakes.FakeCredential.create_one_credential()
|
|
self.credentials_mock.get.return_value = self.credential
|
|
self.data = (
|
|
self.credential.blob,
|
|
self.credential.id,
|
|
self.credential.project_id,
|
|
self.credential.type,
|
|
self.credential.user_id,
|
|
)
|
|
|
|
self.cmd = credential.ShowCredential(self.app, None)
|
|
|
|
def test_credential_show(self):
|
|
arglist = [
|
|
self.credential.id,
|
|
]
|
|
verifylist = [
|
|
('credential', self.credential.id),
|
|
]
|
|
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
|
|
|
|
columns, data = self.cmd.take_action(parsed_args)
|
|
|
|
self.credentials_mock.get.assert_called_once_with(self.credential.id)
|
|
self.assertEqual(self.columns, columns)
|
|
self.assertEqual(self.data, data)
|