def test_clone_image_cloneableshare_notraw(self):
drv = self._driver
mox = self.mox
volume = {'name': 'vol', 'size': '20'}
mox.StubOutWithMock(drv, '_find_image_in_cache')
mox.StubOutWithMock(drv, '_is_cloneable_share')
mox.StubOutWithMock(drv, '_get_mount_point_for_share')
mox.StubOutWithMock(image_utils, 'qemu_img_info')
mox.StubOutWithMock(drv, '_clone_volume')
mox.StubOutWithMock(drv, '_discover_file_till_timeout')
mox.StubOutWithMock(drv, '_set_rw_permissions_for_all')
mox.StubOutWithMock(drv, '_resize_image_file')
mox.StubOutWithMock(image_utils, 'convert_image')
mox.StubOutWithMock(drv, '_register_image_in_cache')
mox.StubOutWithMock(drv, '_is_share_vol_compatible')
drv._find_image_in_cache(IgnoreArg()).AndReturn([])
drv._is_cloneable_share('nfs://127.0.0.1/share/img-id').AndReturn(
'127.0.0.1:/share')
drv._is_share_vol_compatible(IgnoreArg(), IgnoreArg()).AndReturn(True)
drv._get_mount_point_for_share('127.0.0.1:/share').AndReturn('/mnt')
image_utils.qemu_img_info('/mnt/img-id').AndReturn(
self.get_img_info('notraw'))
image_utils.convert_image(IgnoreArg(), IgnoreArg(), 'raw')
image_utils.qemu_img_info('/mnt/vol').AndReturn(
self.get_img_info('raw'))
drv._register_image_in_cache(IgnoreArg(), IgnoreArg())
drv._get_mount_point_for_share('127.0.0.1:/share').AndReturn('/mnt')
drv._discover_file_till_timeout(IgnoreArg()).AndReturn(True)
drv._set_rw_permissions_for_all('/mnt/vol')
drv._resize_image_file({'name': 'vol'}, IgnoreArg())
mox.ReplayAll()
drv.clone_image(volume, ('nfs://127.0.0.1/share/img-id', None),
'image_id', {})
mox.VerifyAll()
def test_update_user_with_passwords_not_matching(self):
api.keystone.user_get(IsA(http.HttpRequest), '1',
admin=True).AndReturn(self.user)
api.keystone.tenant_list(IgnoreArg(), user=self.user.id) \
.AndReturn([self.tenants.list(), False])
self.mox.ReplayAll()
self.selenium.get("%s%s" % (self.live_server_url, USER_UPDATE_URL))
body = self.selenium.find_element_by_tag_name("body")
self.assertFalse(
"Passwords do not match" in body.text,
"Error message should not be visible at loading time")
self.selenium.find_element_by_id("id_password").send_keys("test")
self.selenium.find_element_by_id("id_confirm_password").send_keys("te")
self.selenium.find_element_by_id("id_email").clear()
body = self.selenium.find_element_by_tag_name("body")
self.assertTrue("Passwords do not match" in body.text,
"Error message not found in body")
def test_disable_user(self):
OTHER_USER = '******'
formData = {
'method': 'UserEnableDisableForm',
'id': OTHER_USER,
'enabled': 'disable'
}
self.mox.StubOutWithMock(api, 'user_update_enabled')
api.user_update_enabled(IgnoreArg(), OTHER_USER,
False).AndReturn(self.mox.CreateMock(api.User))
self.mox.ReplayAll()
res = self.client.post(reverse('syspanel_users'), formData)
self.assertRedirectsNoFollow(res, reverse('syspanel_users'))
self.mox.VerifyAll()
def test_enable_disable_user_exception(self):
OTHER_USER = '******'
formData = {
'method': 'UserEnableDisableForm',
'id': OTHER_USER,
'enabled': 'enable'
}
self.mox.StubOutWithMock(api, 'user_update_enabled')
api_exception = api_exceptions.ApiException('apiException',
message='apiException')
api.user_update_enabled(IgnoreArg(), OTHER_USER,
True).AndRaise(api_exception)
self.mox.ReplayAll()
res = self.client.post(USERS_INDEX_URL, formData)
self.assertRedirectsNoFollow(res, USERS_INDEX_URL)
def test_index(self):
domain_id = self._get_domain_id()
groups = self._get_groups(domain_id)
api.keystone.group_list(IgnoreArg()).AndReturn(groups)
self.mox.ReplayAll()
res = self.client.get(GROUPS_INDEX_URL)
self.assertTemplateUsed(res, GROUPS_INDEX_VIEW_TEMPLATE)
self.assertItemsEqual(res.context['table'].data, groups)
if domain_id:
for group in res.context['table'].data:
self.assertItemsEqual(group.domain_id, domain_id)
self.assertContains(res, 'Create Group')
self.assertContains(res, 'Edit')
self.assertContains(res, 'Delete Group')
def test_attempt_delivery_transientrelayerror_no_retry(self):
task = self.mox.CreateMockAnything()
subtask = self.mox.CreateMockAnything()
result = self.mox.CreateMockAnything()
result.id = '12345'
self.relay.attempt(self.env, 0).AndRaise(TransientRelayError('transient', Reply('450', 'transient error')))
self.celery.task(IgnoreArg()).AndReturn(task)
task.s(self.bounce, 0).AndReturn(subtask)
subtask.apply_async().AndReturn(result)
self.mox.ReplayAll()
def return_bounce(envelope, reply):
self.assertEqual(self.env, envelope)
return self.bounce
def no_retry(envelope, attempts):
self.assertEqual(self.env, envelope)
self.assertEqual(1, attempts)
return None
queue = CeleryQueue(self.celery, self.relay, backoff=no_retry, bounce_factory=return_bounce)
queue.attempt_delivery(self.env, 0)
def test_create_container_post(self):
formData = {'name': 'containerName', 'method': 'CreateContainer'}
self.mox.StubOutWithMock(api, 'swift_create_container')
api.swift_create_container(IsA(http.HttpRequest), 'containerName')
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(str))
self.mox.ReplayAll()
res = self.client.post(
reverse('dash_containers_create',
args=[self.request.user.tenant_id]), formData)
self.assertRedirectsNoFollow(
res, reverse('dash_containers',
args=[self.request.user.tenant_id]))
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_index_with_keystone_can_edit_group_false(self):
domain_id = self._get_domain_id()
groups = self._get_groups(domain_id)
api.keystone.group_list(IgnoreArg(), domain=domain_id) \
.AndReturn(groups)
api.keystone.keystone_can_edit_group() \
.MultipleTimes().AndReturn(False)
self.mox.ReplayAll()
res = self.client.get(GROUPS_INDEX_URL)
self.assertTemplateUsed(res, constants.GROUPS_INDEX_VIEW_TEMPLATE)
self.assertItemsEqual(res.context['table'].data, groups)
self.assertNotContains(res, 'Create Group')
self.assertNotContains(res, 'Edit')
self.assertNotContains(res, 'Delete Group')
def test_create(self):
user = self.users.get(id="1")
domain = self._get_default_domain()
domain_id = domain.id
role = self.roles.first()
api.keystone.get_default_domain(IgnoreArg()) \
.MultipleTimes().AndReturn(domain)
api.keystone.tenant_list(IgnoreArg(),
domain=domain_id,
user=None) \
.AndReturn([self.tenants.list(), False])
api.keystone.user_create(IgnoreArg(),
name=user.name,
description=user.description,
email=user.email,
password=user.password,
project=self.tenant.id,
enabled=True,
domain=domain_id).AndReturn(user)
api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
api.keystone.get_default_role(IgnoreArg()).AndReturn(role)
api.keystone.roles_for_user(IgnoreArg(), user.id, self.tenant.id)
api.keystone.add_tenant_user_role(IgnoreArg(), self.tenant.id, user.id,
role.id)
self.mox.ReplayAll()
formData = {
'method': 'CreateUserForm',
'domain_id': domain_id,
'name': user.name,
'description': user.description,
'email': user.email,
'password': user.password,
'project': self.tenant.id,
'role_id': self.roles.first().id,
'enabled': True,
'confirm_password': user.password
}
res = self.client.post(USER_CREATE_URL, formData)
self.assertNoFormErrors(res)
self.assertMessageCount(success=1)
def test_create_instance_snapshot(self):
server = self.servers.first()
snapshot_server = deepcopy(server)
setattr(snapshot_server, 'OS-EXT-STS:task_state', "IMAGE_SNAPSHOT")
self.mox.StubOutWithMock(api, 'server_get')
self.mox.StubOutWithMock(api, 'snapshot_create')
self.mox.StubOutWithMock(api, 'snapshot_list_detailed')
self.mox.StubOutWithMock(api, 'image_list_detailed')
self.mox.StubOutWithMock(api, 'volume_snapshot_list')
self.mox.StubOutWithMock(api, 'server_list')
self.mox.StubOutWithMock(api, 'flavor_list')
self.mox.StubOutWithMock(api, 'server_delete')
self.mox.StubOutWithMock(api, 'volume_list')
api.server_get(IsA(http.HttpRequest), server.id).AndReturn(server)
api.snapshot_create(IsA(http.HttpRequest), server.id, "snapshot1")
api.server_get(IsA(http.HttpRequest), server.id).AndReturn(server)
api.snapshot_list_detailed(IsA(http.HttpRequest),
marker=None).AndReturn([[], False])
api.image_list_detailed(IsA(http.HttpRequest),
marker=None).AndReturn([[], False])
api.volume_snapshot_list(IsA(http.HttpRequest)).AndReturn([])
api.volume_list(IsA(http.HttpRequest)).AndReturn(self.volumes.list())
api.server_list(IsA(http.HttpRequest)).AndReturn([snapshot_server])
api.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
self.mox.ReplayAll()
formData = {
'instance_id': server.id,
'method': 'CreateSnapshot',
'tenant_id': server.tenant_id,
'name': 'snapshot1'
}
url = reverse('horizon:nova:images_and_snapshots:snapshots:create',
args=[server.id])
redir_url = reverse('horizon:nova:images_and_snapshots:index')
res = self.client.post(url, formData)
self.assertRedirects(res, redir_url)
res = self.client.get(INDEX_URL)
self.assertContains(
res, '<td class="status_unknown sortable">'
'Snapshotting</td>', 1)
def test_attempt_delivery_unhandlederror(self):
task = self.mox.CreateMockAnything()
subtask = self.mox.CreateMockAnything()
result = self.mox.CreateMockAnything()
result.id = '12345'
self.relay.attempt(self.env, 0).AndRaise(Exception('unhandled error'))
self.celery.task(IgnoreArg()).AndReturn(task)
task.s(self.bounce, 0).AndReturn(subtask)
subtask.apply_async().AndReturn(result)
self.mox.ReplayAll()
def return_bounce(envelope, reply):
self.assertEqual(self.env, envelope)
self.assertEqual('4.0.0 Unhandled delivery error: unhandled error (Too many retries)', reply.message)
return self.bounce
def no_retry(envelope, attempts):
self.assertEqual(self.env, envelope)
self.assertEqual(1, attempts)
return None
queue = CeleryQueue(self.celery, self.relay, backoff=no_retry, bounce_factory=return_bounce)
self.assertRaises(Exception, queue.attempt_delivery, self.env, 0)
def test_get_item(self):
self.storage_mocker.StubOutWithMock(storage, 'select_item')
blob_data1 = bytes(bytearray([1, 2, 3, 4, 5]))
blob_data2 = bytes(bytearray([5, 4, 3, 2, 1]))
hash_key = "4.5621201231232132132132132132132142354E126"
range_key = "range"
storage.select_item(
IgnoreArg(),
IgnoreArg(),
IgnoreArg(),
select_type=IgnoreArg(),
limit=IgnoreArg(),
consistent=IgnoreArg()).AndReturn(
models.SelectResult(items=[{
"hash_key":
models.AttributeValue('N', hash_key),
"range_key":
models.AttributeValue('S', range_key),
"value_blob":
models.AttributeValue('B', decoded_value=blob_data1),
"value_blob_set":
models.AttributeValue(
'BS', decoded_value={blob_data1, blob_data2})
}]))
self.storage_mocker.ReplayAll()
table = Table('test_table', connection=self.DYNAMODB_CON)
item = table.get_item(consistent=False, hash_key=1, range_key="range")
expected_item = {
"hash_key":
decimal.Decimal(hash_key),
"range_key":
range_key,
"value_blob":
types.Binary(blob_data1),
"value_blob_set":
set([types.Binary(blob_data1),
types.Binary(blob_data2)])
}
self.assertDictEqual(expected_item, dict(item.items()))
self.storage_mocker.VerifyAll()
def test_modify_users(self):
self.mox.StubOutWithMock(api.keystone, 'tenant_get')
self.mox.StubOutWithMock(api.keystone, 'user_list')
self.mox.StubOutWithMock(api.keystone, 'roles_for_user')
api.keystone.tenant_get(IgnoreArg(), self.tenant.id, admin=True) \
.AndReturn(self.tenant)
api.keystone.user_list(IsA(http.HttpRequest)) \
.AndReturn(self.users.list())
api.keystone.user_list(IsA(http.HttpRequest), self.tenant.id) \
.AndReturn([self.user])
api.keystone.roles_for_user(IsA(http.HttpRequest),
self.user.id,
self.tenant.id) \
.AndReturn(self.roles.list())
self.mox.ReplayAll()
url = reverse('horizon:syspanel:projects:users',
args=(self.tenant.id,))
res = self.client.get(url)
self.assertEqual(res.status_code, 200)
self.assertTemplateUsed(res, 'syspanel/projects/users.html')
def test_port_create(self):
self.mox.StubOutWithMock(api, "quantum_create_port")
api.quantum_create_port(IsA(http.HttpRequest), 'n1').AndReturn(True)
formData = {'ports_num': 1,
'network': 'n1',
'method': 'CreatePort'}
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(basestring))
self.mox.ReplayAll()
res = self.client.post(reverse('horizon:nova:networks:port_create',
args=["n1"]),
formData)
self.assertRedirectsNoFollow(res,
reverse('horizon:nova:networks:detail',
args=["n1"]))
def test_delete_container_nonempty(self):
formData = {'container_name': 'containerName',
'method': 'DeleteContainer'}
exception = ContainerNotEmpty('containerNotEmpty')
self.mox.StubOutWithMock(api, 'swift_delete_container')
api.swift_delete_container(
IsA(http.HttpRequest),
'containerName').AndRaise(exception)
self.mox.StubOutWithMock(messages, 'error')
messages.error(IgnoreArg(), IsA(unicode))
self.mox.ReplayAll()
res = self.client.post(CONTAINER_INDEX_URL, formData)
self.assertRedirectsNoFollow(res, CONTAINER_INDEX_URL)
def test_find_old_cache_files_notexists(self):
drv = self._driver
mox = self.mox
cmd = [
'find', '/mnt', '-maxdepth', '1', '-name', 'img-cache*', '-amin',
'+720'
]
setattr(drv.configuration, 'expiry_thres_minutes', 720)
mox.StubOutWithMock(drv, '_get_mount_point_for_share')
mox.StubOutWithMock(drv, '_execute')
drv._get_mount_point_for_share(IgnoreArg()).AndReturn('/mnt')
drv._execute(*cmd, run_as_root=True).AndReturn((None, ''))
mox.ReplayAll()
res = drv._find_old_cache_files('share')
mox.VerifyAll()
if len(res) == 0:
pass
else:
self.fail('No files expected but got return values.')
def test_update_user_with_passwords_not_matching(self):
api.keystone.user_get(IsA(http.HttpRequest), '1',
admin=True).AndReturn(self.user)
api.keystone.domain_get(IsA(http.HttpRequest), '1') \
.AndReturn(self.domain)
api.keystone.tenant_list(IgnoreArg(),
domain=self.user.domain_id,
user=self.user.id) \
.AndReturn([self.tenants.list(), False])
self.mox.ReplayAll()
self.selenium.get("%s%s" % (self.live_server_url, USER_UPDATE_URL))
self.assertFalse(self._is_element_present("id_confirm_password_error"),
"Password error element shouldn't yet exist.")
self.selenium.find_element_by_id("id_password").send_keys("test")
self.selenium.find_element_by_id("id_confirm_password").send_keys("te")
self.selenium.find_element_by_id("id_email").clear()
self.assertTrue(self._is_element_present("id_confirm_password_error"),
"Couldn't find password error element.")
def test_cinder_services_index(self):
cinder_services = self.cinder_services.list()
api.nova.service_list(IsA(http.HttpRequest)).AndReturn([])
api.cinder.service_list(IsA(http.HttpRequest)).\
AndReturn(cinder_services)
api.neutron.agent_list(IsA(http.HttpRequest)).AndReturn([])
api.base.is_service_enabled(IsA(http.HttpRequest), IgnoreArg()) \
.MultipleTimes().AndReturn(True)
api.neutron.is_extension_supported(IsA(http.HttpRequest),
'agent').AndReturn(True)
self.mox.ReplayAll()
res = self.client.get(INDEX_URL)
cinder_services_tab = res.context['tab_group'].\
get_tab('cinder_services')
self.assertTemplateUsed(res, 'admin/info/index.html')
self.assertQuerysetEqual(cinder_services_tab._tables
['cinder_services'].data,
['<Service: cinder-scheduler>',
'<Service: cinder-volume>'])
def test_describe_unexisting_table(self):
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.describe_table(IgnoreArg(),
'test_table1').AndRaise(TableNotExistsException)
self.storage_mocker.ReplayAll()
table = Table('test_table1', connection=self.DYNAMODB_CON)
try:
table.describe()
except JSONResponseError as e:
self.assertEqual(
e.body['__type'],
'com.amazonaws.dynamodb.v20111205#ResourceNotFoundException')
self.assertEqual(
e.body['message'],
'The resource which is being requested does not exist.')
def test_container_meta_put_invalid(self):
formData = {
'container_name': 'containerName',
'method': 'ContainerMeta',
'header_name': 'x-invalid-meta-test',
'header_value': 'hoge'
}
self.mox.StubOutWithMock(messages, 'error')
self.mox.StubOutWithMock(api, 'swift_set_container_info')
messages.error(IsA(http.HttpRequest), IgnoreArg())
self.mox.ReplayAll()
res = self.client.post(
reverse('dash_containers_meta',
args=[self.request.user.tenant_id, self.container.name]),
formData)
self.assertRedirectsNoFollow(
res,
reverse('dash_containers_meta',
args=[self.request.user.tenant_id, self.container.name]))
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_update_with_keystone_can_edit_user_false(self):
user = self.users.get(id="1")
api.user_get(IsA(http.HttpRequest), '1', admin=True).AndReturn(user)
api.tenant_list(IgnoreArg(), admin=True).AndReturn(self.tenants.list())
api.keystone_can_edit_user().AndReturn(False)
api.keystone_can_edit_user().AndReturn(False)
api.user_update_tenant(IsA(http.HttpRequest), user.id,
self.tenant.id).AndReturn(None)
self.mox.ReplayAll()
formData = {
'method': 'UpdateUserForm',
'tenant_id': self.tenant.id,
'id': user.id
}
res = self.client.post(USER_UPDATE_URL, formData)
self.assertNoFormErrors(res)
def test_container_public_put(self):
ret_container = self.container
ret_container.headers = [('x-container-meta-web-index', 'test'),
('x-container-meta-web-listing-css', 'css'),
('x-container-meta-web-error', 'err'),
('x-container-meta-web-listing', 'fuga')]
formData = {
'container_name': 'containerName',
'method': 'MakePublicContainer',
'index_object_name': self.object.name,
'css_object_name': self.object.name,
'html_listing': True,
'public_html': True,
'use_css_in_listing': True,
'error': 'errorsuffix'
}
self.mox.StubOutWithMock(api, 'swift_get_container')
api.swift_get_container(IsA(http.HttpRequest),
self.container.name).AndReturn(ret_container)
self.mox.StubOutWithMock(api, 'swift_get_objects')
api.swift_get_objects(IsA(http.HttpRequest),
self.container.name).AndReturn([self.object])
self.mox.StubOutWithMock(api, 'swift_set_container_info')
api.swift_set_container_info(IsA(http.HttpRequest),
self.container.name, IgnoreArg())
self.mox.ReplayAll()
res = self.client.post(
reverse('dash_containers_public',
args=['tenant', self.container.name]), formData)
#self.assertRedirectsNoFollow(res, reverse('dash_containers_public',
# args=[self.request.user.tenant_id, self.container.name]))
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_router_with_interface_delete(self):
router = self.routers.first()
ports = self.ports.list()
quota_data = self.quota_usages.first()
quota_data['routers']['available'] = 5
api.neutron.router_list(IsA(http.HttpRequest),
tenant_id=self.tenant.id,
search_opts=None).AndReturn(
self.routers.list())
quotas.tenant_quota_usages(
IsA(http.HttpRequest)) \
.MultipleTimes().AndReturn(quota_data)
self._mock_external_network_list()
api.neutron.router_list(IsA(http.HttpRequest),
tenant_id=self.tenant.id,
search_opts=None).AndReturn(
self.routers.list())
self._mock_external_network_list()
api.neutron.router_list(IsA(http.HttpRequest),
tenant_id=self.tenant.id,
search_opts=None).AndReturn(
self.routers.list())
self._mock_external_network_list()
api.neutron.port_list(IsA(http.HttpRequest),
device_id=router.id, device_owner=IgnoreArg())\
.AndReturn(ports)
for port in ports:
api.neutron.router_remove_interface(IsA(http.HttpRequest),
router.id,
port_id=port.id)
api.neutron.router_delete(IsA(http.HttpRequest), router.id)
self.mox.ReplayAll()
res = self.client.get(self.INDEX_URL)
formData = {'action': 'Routers__delete__' + router.id}
res = self.client.post(self.INDEX_URL, formData, follow=True)
self.assertNoFormErrors(res)
self.assertMessageCount(response=res, success=1)
self.assertIn('Deleted Router: ' + router.name, res.content)
def test_index(self):
services = self.services.list()
api.nova.service_list(IsA(http.HttpRequest)).AndReturn(services)
api.base.is_service_enabled(IsA(http.HttpRequest), IgnoreArg()) \
.MultipleTimes().AndReturn(True)
api.neutron.is_extension_supported(IsA(http.HttpRequest),
'agent').AndReturn(True)
agents = self.agents.list()
api.neutron.agent_list(IsA(http.HttpRequest)).AndReturn(agents)
cinder_services = self.cinder_services.list()
api.cinder.service_list(IsA(http.HttpRequest)).\
AndReturn(cinder_services)
self.mox.ReplayAll()
res = self.client.get(INDEX_URL)
self.assertTemplateUsed(res, 'admin/info/index.html')
services_tab = res.context['tab_group'].get_tab('services')
self.assertQuerysetEqual(services_tab._tables['services'].data,
['<Service: compute>',
'<Service: volume>',
'<Service: image>',
'<Service: identity (native backend)>',
'<Service: object-store>',
'<Service: network>',
'<Service: ec2>',
'<Service: metering>',
'<Service: orchestration>',
'<Service: database>',
'<Service: data_processing>', ])
network_agents_tab = res.context['tab_group'].get_tab('network_agents')
self.assertQuerysetEqual(
network_agents_tab._tables['network_agents'].data,
[agent.__repr__() for agent in self.agents.list()]
)
self.mox.VerifyAll()
def test_select_item_count(self):
self.storage_mocker.StubOutWithMock(storage, 'select_item')
storage.select_item(IgnoreArg(),
IgnoreArg(),
IgnoreArg(),
select_type=SelectType.count(),
index_name=IgnoreArg(),
limit=IgnoreArg(),
exclusive_start_key=IgnoreArg(),
consistent=IgnoreArg(),
order_type=IgnoreArg()).AndReturn(
models.SelectResult(count=100500))
self.storage_mocker.ReplayAll()
table = Table('test_table', connection=self.DYNAMODB_CON)
count = table.query_count(consistent=False, hash_key__eq=1)
self.assertEqual(count, 100500)
self.storage_mocker.VerifyAll()
def test_update_validation_for_password_too_long(self):
user = self.users.get(id="1")
api.user_get(IsA(http.HttpRequest), '1', admin=True).AndReturn(user)
api.tenant_list(IgnoreArg(), admin=True).AndReturn(self.tenants.list())
self.mox.ReplayAll()
formData = {
'method': 'UpdateUserForm',
'id': user.id,
'name': user.name,
'email': user.email,
'password': '******',
'tenant_id': self.tenant.id,
'confirm_password': '******'
}
res = self.client.post(USER_UPDATE_URL, formData)
self.assertFormError(res, "form", 'password',
['Password must be between 8 and 18 characters.'])
def test_update_with_keystone_can_edit_user_false(self):
user = self.users.get(id="1")
api.keystone.user_get(IsA(http.HttpRequest),
'1',
admin=True).AndReturn(user)
api.keystone.tenant_list(IgnoreArg(), user=user.id) \
.AndReturn([self.tenants.list(), False])
api.keystone.keystone_can_edit_user().AndReturn(False)
api.keystone.keystone_can_edit_user().AndReturn(False)
self.mox.ReplayAll()
formData = {'method': 'UpdateUserForm',
'id': user.id,
'name': user.name,
'project': self.tenant.id, }
res = self.client.post(USER_UPDATE_URL, formData)
self.assertNoFormErrors(res)
self.assertMessageCount(error=1)
def test_port_detach(self):
self.mox.StubOutWithMock(api, 'quantum_network_details')
self.mox.StubOutWithMock(api, 'quantum_list_ports')
self.mox.StubOutWithMock(api, 'quantum_port_attachment')
self.mox.StubOutWithMock(api, 'quantum_port_details')
self.mox.StubOutWithMock(api, 'get_vif_ids')
self.mox.StubOutWithMock(api, "quantum_set_port_state")
network_details = {'network': {'id': 'n1', 'name': 'network1'}}
api.quantum_network_details(IsA(http.HttpRequest),
'n1').AndReturn(network_details)
api.quantum_list_ports(IsA(http.HttpRequest),
'n1').AndReturn(self.ports)
api.quantum_port_attachment(IsA(http.HttpRequest), 'n1',
'p1').AndReturn(self.port_attachment)
api.quantum_port_details(IsA(http.HttpRequest), 'n1',
'p1').AndReturn(self.port_details)
api.get_vif_ids(IsA(http.HttpRequest)).AndReturn(self.vifs)
api.quantum_set_port_state(IsA(http.HttpRequest), 'n1', 'p1', {
'port': {
'state': 'DOWN'
}
}).AndReturn(True)
formData = {'action': "network_details__detach_port__p1"}
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(basestring))
self.mox.ReplayAll()
detail_url = reverse('horizon:nova:networks:detail', args=["n1"])
res = self.client.post(detail_url, formData)
self.assertRedirectsNoFollow(res, detail_url)
def test_meta_remove_invalid(self):
OBJECT_NAME = 'objectName'
formData = {'method' : 'ObjectMetaRemove',
'container_name' : self.CONTAINER_NAME,
'object_name' : OBJECT_NAME,
'header_name' : 'x-invalid-meta-hoge'
}
self.mox.StubOutWithMock(messages, 'error')
messages.error(IsA(http.HttpRequest), IgnoreArg())
self.mox.ReplayAll()
res = self.client.post(reverse('dash_objects_meta',
args=[self.TEST_TENANT,
self.CONTAINER_NAME,
OBJECT_NAME]), formData)
self.assertRedirectsNoFollow(res, reverse('dash_objects_meta',
args=[self.TEST_TENANT,
self.CONTAINER_NAME,
OBJECT_NAME]))
self.mox.VerifyAll()
def test_instance_vnc(self):
INSTANCE_ID = self.servers[0].id
CONSOLE_OUTPUT = '/vncserver'
console_mock = self.mox.CreateMock(api.Console)
console_mock.output = CONSOLE_OUTPUT
self.mox.StubOutWithMock(api, 'console_create')
self.mox.StubOutWithMock(api, 'server_get')
api.server_get(IsA(http.HttpRequest),
str(self.servers[0].id)).AndReturn(self.servers[0])
api.console_create(IgnoreArg(), unicode(INSTANCE_ID),
'vnc').AndReturn(console_mock)
self.mox.ReplayAll()
res = self.client.get(
reverse('horizon:nova:instances_and_volumes:instances:vnc',
args=[INSTANCE_ID]))
self.assertRedirectsNoFollow(res,
CONSOLE_OUTPUT + '&title=serverName(1)')
