def test_getTasksStatus(self):
self.mock_thrift_client.getTasksStatus(
IsA(TaskQuery)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().getTasksStatus(TaskQuery())
def test_replaceCronTemplate(self):
self.mock_thrift_client.replaceCronTemplate(
IsA(JobConfiguration),
IsA(Lock)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().replaceCronTemplate(JobConfiguration(), Lock())
def test_descheduleCronJob(self):
self.mock_thrift_client.descheduleCronJob(
IsA(JobKey)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().descheduleCronJob(JOB_KEY)
def test_update_flavor_with_extra_specs(self):
# The second element has extra specs
flavor = self.flavors.list()[1]
projects = self.tenants.list()
eph = getattr(flavor, 'OS-FLV-EXT-DATA:ephemeral')
extra_specs = getattr(flavor, 'extra_specs')
new_flavor = flavors.Flavor(
flavors.FlavorManager(None), {
'id': "cccccccc-cccc-cccc-cccc-cccccccccccc",
'name': flavor.name,
'vcpus': flavor.vcpus + 1,
'disk': flavor.disk,
'ram': flavor.ram,
'swap': flavor.swap,
'OS-FLV-EXT-DATA:ephemeral': eph,
'extra_specs': extra_specs
})
# GET/init, set up expected behavior
api.nova.flavor_get(IsA(http.HttpRequest), flavor.id) \
.MultipleTimes().AndReturn(flavor)
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.MultipleTimes().AndReturn([projects, False])
# POST/init
api.nova.flavor_list(IsA(http.HttpRequest), None) \
.AndReturn(self.flavors.list())
api.nova.flavor_get_extras(IsA(http.HttpRequest),
flavor.id, raw=True) \
.AndReturn(extra_specs)
api.nova.flavor_delete(IsA(http.HttpRequest), flavor.id)
api.nova.flavor_create(IsA(http.HttpRequest),
new_flavor.name,
new_flavor.ram,
new_flavor.vcpus,
new_flavor.disk,
swap=new_flavor.swap,
ephemeral=eph,
is_public=True).AndReturn(new_flavor)
api.nova.flavor_extra_set(IsA(http.HttpRequest), new_flavor.id,
extra_specs)
self.mox.ReplayAll()
#run get test
url = reverse('horizon:admin:flavors:update', args=[flavor.id])
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, "admin/flavors/update.html")
#run post test
workflow_data = {
'flavor_id': flavor.id,
'name': new_flavor.name,
'vcpus': new_flavor.vcpus,
'memory_mb': new_flavor.ram,
'disk_gb': new_flavor.disk,
'swap_mb': new_flavor.swap,
'eph_gb': eph,
'is_public': True
}
resp = self.client.post(url, workflow_data)
self.assertNoFormErrors(resp)
self.assertMessageCount(success=1)
self.assertRedirectsNoFollow(resp, INDEX_URL)
def test_setup_should_throw_error_if_used_ratio_less_than_zero(self):
"""do_setup should throw error if nfs_used_ratio is less than 0."""
drv = self._driver
self.configuration.nfs_used_ratio = -1
self.assertRaises(exception.NfsException, drv.do_setup,
IsA(context.RequestContext))
def test_launch_stack_with_parameter_group(self):
template = {
'data': ('heat_template_version: 2013-05-23\n'
'parameters:\n'
' last_param:\n'
' type: string\n'
' first_param:\n'
' type: string\n'
' middle_param:\n'
' type: string\n'
'parameter_groups:\n'
'- parameters:\n'
' - first_param\n'
' - middle_param\n'
' - last_param\n'),
'validate': {
'Description': 'No description',
'Parameters': {
'last_param': {
'Label': 'last_param',
'Description': '',
'Type': 'String',
'NoEcho': 'false'
},
'first_param': {
'Label': 'first_param',
'Description': '',
'Type': 'String',
'NoEcho': 'false'
},
'middle_param': {
'Label': 'middle_param',
'Description': '',
'Type': 'String',
'NoEcho': 'true'
}
},
'ParameterGroups': [
{
'parameters': [
'first_param',
'middle_param',
'last_param'
]
}
]
}
}
api.heat.template_validate(IsA(http.HttpRequest),
template=template['data']) \
.AndReturn(template['validate'])
self.mox.ReplayAll()
url = reverse('horizon:project:stacks:select_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/select_template.html')
form_data = {'template_source': 'raw',
'template_data': template['data'],
'method': forms.TemplateForm.__name__}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/create.html')
# ensure the fields were rendered in the correct order
regex = re.compile('^.*>first_param<.*>middle_param<.*>last_param<.*$',
flags=re.DOTALL)
self.assertRegexpMatches(res.content.decode('utf-8'), regex)
def test_edit_stack_template(self):
template = self.stack_templates.first()
stack = self.stacks.first()
# GET to template form
api.heat.stack_get(IsA(http.HttpRequest),
stack.id).AndReturn(stack)
# POST template form, validation
api.heat.template_validate(IsA(http.HttpRequest),
template=template.data) \
.AndReturn(json.loads(template.validate))
# GET to edit form
api.heat.stack_get(IsA(http.HttpRequest),
stack.id).AndReturn(stack)
api.heat.template_get(IsA(http.HttpRequest),
stack.id) \
.AndReturn(json.loads(template.validate))
# POST to edit form
api.heat.stack_get(IsA(http.HttpRequest),
stack.id).AndReturn(stack)
fields = {
'stack_name': stack.stack_name,
'disable_rollback': True,
'timeout_mins': 61,
'password': '******',
'template': IsA(unicode),
'parameters': IsA(dict)
}
api.heat.stack_update(IsA(http.HttpRequest),
stack_id=stack.id,
**fields)
self.mox.ReplayAll()
url = reverse('horizon:project:stacks:change_template',
args=[stack.id])
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/change_template.html')
form_data = {'template_source': 'raw',
'template_data': template.data,
'method': forms.ChangeTemplateForm.__name__}
res = self.client.post(url, form_data)
url = reverse('horizon:project:stacks:edit_stack',
args=[stack.id, ])
form_data = {'template_source': 'raw',
'template_data': template.data,
'password': '******',
'parameters': template.validate,
'stack_name': stack.stack_name,
'stack_id': stack.id,
"timeout_mins": 61,
"disable_rollback": True,
"__param_DBUsername": "******",
"__param_LinuxDistribution": "F17",
"__param_InstanceType": "m1.small",
"__param_KeyName": "test",
"__param_DBPassword": "******",
"__param_DBRootPassword": "******",
"__param_DBName": "wordpress",
'method': forms.EditStackForm.__name__}
res = self.client.post(url, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
def test_endMaintenance(self):
self.mock_thrift_client.endMaintenance(
IsA(Hosts)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().endMaintenance(Hosts())
def test_setQuota(self):
self.mock_thrift_client.setQuota(
IgnoreArg(), IsA(ResourceAggregate)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().setQuota(ROLE, ResourceAggregate())
def test_startJobUpdate(self):
self.mock_thrift_client.startJobUpdate(
IsA(JobUpdateRequest)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().startJobUpdate(JobUpdateRequest())
def test_drainHosts(self):
self.mock_thrift_client.drainHosts(
IsA(Hosts)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().drainHosts(Hosts())
def test_getJobUpdateSummaries(self):
self.mock_thrift_client.getJobUpdateSummaries(
IsA(JobUpdateQuery)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().getJobUpdateSummaries(JobUpdateQuery())
def test_addInstances(self):
self.mock_thrift_client.addInstances(IsA(JobKey),
1).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().addInstances(JobKey(), 1)
def test_killTasks(self):
self.mock_thrift_client.killTasks(
IsA(JobKey), IgnoreArg()).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().killTasks(JobKey(), {0})
def test_create_with_rules(self):
self.stubs.Set(db, "group_get_by_gid", fake_group_get_by_id)
self.stubs.Set(db, "securitygroup_get_by_securitygroup_id",
fake_securitygroup_get_by_securitygroup_id)
self.mox.StubOutWithMock(manager.ResourceOperator,
"securitygroup_create")
name = "test_securitygroup"
security_group = {"neutron_securitygroup_id": "fake_id"}
manager.ResourceOperator.securitygroup_create(
IsA(context.RequestContext), name,
[{
"protocol": "icmp",
"port_range_max": None,
"port_range_min": None,
"remote_neutron_securitygroup_id": "fake_key1",
"remote_ip_prefix": None
}, {
"protocol": "tcp",
"port_range_max": "80",
"port_range_min": "80",
"remote_neutron_securitygroup_id": "fake_key1",
"remote_ip_prefix": None
}]).AndReturn(security_group)
self.mox.StubOutWithMock(db, "securitygroup_create")
db.securitygroup_create(IsA(context.RequestContext),
IsA(dict))\
.AndReturn({"securitygroup_id": SECURITYGROUP_ID,
"neutron_securitygroup_id": "fake_id",
"gid": GID,
"user_id": "noauth",
"project_id": "noauth",
"display_name": name,
"is_default": True})
self.mox.ReplayAll()
request_body = {
"securitygroup": {
"name":
name,
"is_default":
"true",
"securitygrouprules": [{
"protocol":
"icmp",
"remote_securitygroup_id":
SECURITYGROUP_ID1
}, {
"port_range_max":
"80",
"port_range_min":
"80",
"protocol":
"tcp",
"remote_securitygroup_id":
SECURITYGROUP_ID1
}]
}
}
expected = {
"securitygroup": {
"securitygroup_id": SECURITYGROUP_ID,
"neutron_securitygroup_id": "fake_id",
"gid": GID,
"user_id": "noauth",
"project_id": "noauth",
"name": name,
"is_default": True
}
}
url = get_base_url(GID)
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
body = jsonutils.loads(res.body)
self.assertEqual(res.status_code, 201)
for key in body["securitygroup"]:
self.assertEqual(body["securitygroup"][key],
expected["securitygroup"][key])
def test_deleteRecoveryTasks(self):
self.mock_thrift_client.deleteRecoveryTasks(
IsA(TaskQuery)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().deleteRecoveryTasks(TaskQuery())
def test_launch_post(self):
FLAVOR_ID = self.flavors[0].id
IMAGE_ID = '1'
KEY_NAME = self.keypairs[0].name
SERVER_NAME = 'serverName'
USER_DATA = 'userData'
form_data = {'method': 'LaunchForm',
'flavor': FLAVOR_ID,
'image_id': IMAGE_ID,
'key_name': KEY_NAME,
'name': SERVER_NAME,
'user_data': USER_DATA,
'tenant_id': self.TEST_TENANT,
'security_groups': 'default',
}
self.mox.StubOutWithMock(api, 'image_get_meta')
api.image_get_meta(IsA(http.HttpRequest),
IMAGE_ID).AndReturn(self.visibleImage)
self.mox.StubOutWithMock(api, 'tenant_quota_get')
api.tenant_quota_get(IsA(http.HttpRequest),
self.TEST_TENANT).AndReturn(FakeQuota)
self.mox.StubOutWithMock(api, 'flavor_list')
api.flavor_list(IsA(http.HttpRequest)).AndReturn(self.flavors)
self.mox.StubOutWithMock(api, 'keypair_list')
api.keypair_list(IsA(http.HttpRequest)).AndReturn(self.keypairs)
self.mox.StubOutWithMock(api, 'security_group_list')
api.security_group_list(IsA(http.HttpRequest)).AndReturn(
self.security_groups)
# called again by the form
api.image_get_meta(IsA(http.HttpRequest),
IMAGE_ID).AndReturn(self.visibleImage)
self.mox.StubOutWithMock(api, 'flavor_get')
api.flavor_get(IsA(http.HttpRequest),
IsA(unicode)).AndReturn(self.flavors[0])
self.mox.StubOutWithMock(api, 'server_create')
api.server_create(IsA(http.HttpRequest), SERVER_NAME,
self.visibleImage, self.flavors[0],
KEY_NAME, USER_DATA, [self.security_groups[0].name])
self.mox.StubOutWithMock(messages, 'success')
messages.success(IsA(http.HttpRequest), IsA(basestring))
self.mox.ReplayAll()
res = self.client.post(reverse('horizon:nova:images:launch',
args=[IMAGE_ID]),
form_data)
self.assertRedirectsNoFollow(res,
reverse('horizon:nova:instances:index'))
def test_rewriteConfigs(self):
self.mock_thrift_client.rewriteConfigs(
IsA(RewriteConfigsRequest)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().rewriteConfigs(RewriteConfigsRequest())
def test_launch_stack_parameter_types(self):
template = {
'data': ('heat_template_version: 2013-05-23\n'
'parameters:\n'
' param1:\n'
' type: string\n'
' param2:\n'
' type: number\n'
' param3:\n'
' type: json\n'
' param4:\n'
' type: comma_delimited_list\n'
' param5:\n'
' type: boolean\n'),
'validate': {
"Description": "No description",
"Parameters": {
"param1": {
"Type": "String",
"NoEcho": "false",
"Description": "",
"Label": "param1"
},
"param2": {
"Type": "Number",
"NoEcho": "false",
"Description": "",
"Label": "param2"
},
"param3": {
"Type": "Json",
"NoEcho": "false",
"Description": "",
"Label": "param3"
},
"param4": {
"Type": "CommaDelimitedList",
"NoEcho": "false",
"Description": "",
"Label": "param4"
},
"param5": {
"Type": "Boolean",
"NoEcho": "false",
"Description": "",
"Label": "param5"
}
}
}
}
stack = self.stacks.first()
api.heat.template_validate(IsA(http.HttpRequest),
template=template['data']) \
.AndReturn(template['validate'])
api.heat.stack_create(IsA(http.HttpRequest),
stack_name=stack.stack_name,
timeout_mins=60,
disable_rollback=True,
template=template['data'],
parameters={'param1': 'some string',
'param2': 42,
'param3': '{"key": "value"}',
'param4': 'a,b,c',
'param5': True},
password='******')
self.mox.ReplayAll()
url = reverse('horizon:project:stacks:select_template')
res = self.client.get(url)
self.assertTemplateUsed(res, 'project/stacks/select_template.html')
form_data = {'template_source': 'raw',
'template_data': template['data'],
'method': forms.TemplateForm.__name__}
res = self.client.post(url, form_data)
self.assertTemplateUsed(res, 'project/stacks/create.html')
# ensure the fields were rendered correctly
self.assertContains(res,
'<input class="form-control" '
'id="id___param_param1" '
'name="__param_param1" '
'type="text" />', html=True)
if django.VERSION >= (1, 6):
self.assertContains(res,
'<input class="form-control" '
'id="id___param_param2" '
'name="__param_param2" '
'type="number" />', html=True)
else:
self.assertContains(res,
'<input class="form-control" '
'id="id___param_param2" '
'name="__param_param2" '
'type="text" />', html=True)
self.assertContains(res,
'<input class="form-control" '
'id="id___param_param3" '
'name="__param_param3" '
'type="text" />', html=True)
self.assertContains(res,
'<input class="form-control" '
'id="id___param_param4" '
'name="__param_param4" '
'type="text" />', html=True)
self.assertContains(res,
'<input id="id___param_param5" '
'name="__param_param5" '
'type="checkbox" />', html=True)
# post some sample data and make sure it validates
url = reverse('horizon:project:stacks:launch')
form_data = {'template_source': 'raw',
'template_data': template['data'],
'password': '******',
'parameters': json.dumps(template['validate']),
'stack_name': stack.stack_name,
"timeout_mins": 60,
"disable_rollback": True,
"__param_param1": "some string",
"__param_param2": 42,
"__param_param3": '{"key": "value"}',
"__param_param4": "a,b,c",
"__param_param5": True,
'method': forms.CreateStackForm.__name__}
res = self.client.post(url, form_data)
self.assertRedirectsNoFollow(res, INDEX_URL)
def test_edit_rules_invalid_icmp_rule(self):
sec_group = self.security_groups.first()
sec_group_list = self.security_groups.list()
icmp_rule = self.security_group_rules.list()[1]
api.security_group_get(IsA(http.HttpRequest),
sec_group.id).AndReturn(sec_group)
api.security_group_list(
IsA(http.HttpRequest)).AndReturn(sec_group_list)
api.security_group_get(IsA(http.HttpRequest),
sec_group.id).AndReturn(sec_group)
api.security_group_list(
IsA(http.HttpRequest)).AndReturn(sec_group_list)
api.security_group_get(IsA(http.HttpRequest),
sec_group.id).AndReturn(sec_group)
api.security_group_list(
IsA(http.HttpRequest)).AndReturn(sec_group_list)
api.security_group_get(IsA(http.HttpRequest),
sec_group.id).AndReturn(sec_group)
api.security_group_list(
IsA(http.HttpRequest)).AndReturn(sec_group_list)
self.mox.ReplayAll()
formData = {'method': 'AddRule',
'security_group_id': sec_group.id,
'from_port': 256,
'to_port': icmp_rule.to_port,
'ip_protocol': icmp_rule.ip_protocol,
'cidr': icmp_rule.ip_range['cidr'],
'source_group': ''}
res = self.client.post(self.edit_url, formData)
self.assertNoMessages()
self.assertContains(res, "The ICMP type not in range (-1, 255)")
formData = {'method': 'AddRule',
'security_group_id': sec_group.id,
'from_port': icmp_rule.from_port,
'to_port': 256,
'ip_protocol': icmp_rule.ip_protocol,
'cidr': icmp_rule.ip_range['cidr'],
'source_group': ''}
res = self.client.post(self.edit_url, formData)
self.assertNoMessages()
self.assertContains(res, "The ICMP code not in range (-1, 255)")
formData = {'method': 'AddRule',
'security_group_id': sec_group.id,
'from_port': icmp_rule.from_port,
'to_port': None,
'ip_protocol': icmp_rule.ip_protocol,
'cidr': icmp_rule.ip_range['cidr'],
'source_group': ''}
res = self.client.post(self.edit_url, formData)
self.assertNoMessages()
self.assertContains(res, "The ICMP code is invalid")
formData = {'method': 'AddRule',
'security_group_id': sec_group.id,
'from_port': None,
'to_port': icmp_rule.to_port,
'ip_protocol': icmp_rule.ip_protocol,
'cidr': icmp_rule.ip_range['cidr'],
'source_group': ''}
res = self.client.post(self.edit_url, formData)
self.assertNoMessages()
self.assertContains(res, "The ICMP type is invalid")
def test_update_flavor_update_flavor_error(self):
# The first element has no extra specs
flavor = self.flavors.first()
projects = self.tenants.list()
eph = getattr(flavor, 'OS-FLV-EXT-DATA:ephemeral')
extra_specs = getattr(flavor, 'extra_specs')
new_flavor = flavors.Flavor(
flavors.FlavorManager(None), {
'id': "cccccccc-cccc-cccc-cccc-cccccccccccc",
'name': flavor.name,
'vcpus': flavor.vcpus + 1,
'disk': flavor.disk,
'ram': flavor.ram,
'swap': 0,
'OS-FLV-EXT-DATA:ephemeral': eph,
'extra_specs': extra_specs
})
# GET/init, set up expected behavior
api.nova.flavor_get(IsA(http.HttpRequest), flavor.id) \
.MultipleTimes().AndReturn(flavor)
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.MultipleTimes().AndReturn([projects, False])
# POST
api.nova.flavor_list(IsA(http.HttpRequest), None) \
.AndReturn(self.flavors.list())
# POST/init
api.nova.flavor_get_extras(IsA(http.HttpRequest),
flavor.id, raw=True) \
.AndReturn(extra_specs)
api.nova.flavor_delete(IsA(http.HttpRequest), flavor.id)
api.nova.flavor_create(IsA(http.HttpRequest),
new_flavor.name,
new_flavor.ram,
new_flavor.vcpus,
new_flavor.disk,
swap=new_flavor.swap,
ephemeral=eph,
is_public=True)\
.AndRaise(self.exceptions.nova)
# Put mocks in replay mode
self.mox.ReplayAll()
# run get test
url = reverse(constants.FLAVORS_UPDATE_URL, args=[flavor.id])
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, constants.FLAVORS_UPDATE_VIEW_TEMPLATE)
# run post test
workflow_data = {
'flavor_id': flavor.id,
'name': new_flavor.name,
'vcpus': new_flavor.vcpus,
'memory_mb': new_flavor.ram,
'disk_gb': new_flavor.disk,
'swap_mb': new_flavor.swap,
'eph_gb': eph,
'is_public': True
}
resp = self.client.post(url, workflow_data)
self.assertNoFormErrors(resp)
self.assertMessageCount(error=1)
self.assertRedirectsNoFollow(resp,
reverse(constants.FLAVORS_INDEX_URL))
def test_launch_form_instance_count_error(self):
flavor = self.flavors.first()
image = self.images.first()
server = self.servers.first()
volume = self.volumes.first()
sec_group = self.security_groups.first()
avail_zone = self.availability_zones.first()
customization_script = 'user data'
device_name = u'vda'
volume_choice = "%s:vol" % volume.id
quota_usages = self.quota_usages.first()
api.nova.extension_supported('BlockDeviceMappingV2Boot',
IsA(http.HttpRequest)) \
.AndReturn(True)
api.nova.flavor_list(IsA(http.HttpRequest)) \
.AndReturn(self.flavors.list())
api.nova.keypair_list(IsA(http.HttpRequest)) \
.AndReturn(self.keypairs.list())
#.AndReturn([])
api.network.security_group_list(IsA(http.HttpRequest)) \
.AndReturn(self.security_groups.list())
api.nova.availability_zone_list(IsA(http.HttpRequest)) \
.AndReturn(self.availability_zones.list())
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'is_public': True,
'status': 'active'}) \
.AndReturn([self.images.list(), False])
api.glance.image_list_detailed(IsA(http.HttpRequest),
filters={'property-owner_id': self.tenant.id,
'status': 'active'}) \
.AndReturn([[], False])
api.neutron.network_list(IsA(http.HttpRequest),
tenant_id=self.tenant.id,
shared=False) \
.AndReturn(self.networks.list()[:1])
api.neutron.network_list(IsA(http.HttpRequest),
shared=True) \
.AndReturn(self.networks.list()[1:])
# TODO(absubram): Remove if clause and create separate
# test stubs for when profile_support is being used.
# Additionally ensure those are always run even in default setting
if api.neutron.is_port_profiles_supported():
policy_profiles = self.policy_profiles.list()
api.neutron.profile_list(IsA(http.HttpRequest),
'policy').AndReturn(policy_profiles)
cinder.volume_list(IsA(http.HttpRequest)) \
.AndReturn(self.volumes.list())
cinder.volume_snapshot_list(IsA(http.HttpRequest)).AndReturn([])
api.nova.flavor_list(IsA(http.HttpRequest)) \
.AndReturn(self.flavors.list())
api.nova.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.limits['absolute'])
quotas.tenant_quota_usages(IsA(http.HttpRequest)) \
.AndReturn(quota_usages)
api.nova.flavor_list(IsA(http.HttpRequest)) \
.AndReturn(self.flavors.list())
self.mox.ReplayAll()
form_data = {
'flavor': flavor.id,
'source_type': 'image_id',
'image_id': image.id,
'availability_zone': avail_zone.zoneName,
'keypair': '',
'name': server.name,
'customization_script': customization_script,
'project_id': self.tenants.first().id,
'user_id': self.user.id,
'groups': sec_group.name,
'volume_type': 'volume_id',
'volume_id': volume_choice,
'device_name': device_name,
'count': 1
}
url = reverse('horizon:project:instances:launch')
res = self.client.post(url, form_data)
for context in [
l2_context for l1_context in res.context
for l2_context in l1_context
if 'form' in l2_context and l2_context['form'].__class__ ==
customized_create_instance.CustomSetAccessControlsAction
]:
self.assertEqual(context['form'].is_valid(), False)
def test_update_flavor_update_projects_error(self):
# The first element has no extra specs
flavor = self.flavors.first()
projects = self.tenants.list()
flavor_projects = [self.tenants.first()]
eph = getattr(flavor, 'OS-FLV-EXT-DATA:ephemeral')
extra_specs = getattr(flavor, 'extra_specs')
new_flavor = flavors.Flavor(
flavors.FlavorManager(None), {
'id': "cccccccc-cccc-cccc-cccc-cccccccccccc",
'name': flavor.name,
'vcpus': flavor.vcpus + 1,
'disk': flavor.disk,
'ram': flavor.ram,
'swap': 0,
'OS-FLV-EXT-DATA:ephemeral': eph,
'os-flavor-access:is_public': False,
'extra_specs': extra_specs
})
# GET/init, set up expected behavior
api.nova.flavor_get(IsA(http.HttpRequest), flavor.id) \
.MultipleTimes().AndReturn(flavor)
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.MultipleTimes().AndReturn([projects, False])
# POST/init
api.nova.flavor_list(IsA(http.HttpRequest), None) \
.AndReturn(self.flavors.list())
api.nova.flavor_get_extras(IsA(http.HttpRequest),
flavor.id, raw=True) \
.AndReturn(extra_specs)
api.nova.flavor_delete(IsA(http.HttpRequest), flavor.id)
api.nova.flavor_create(IsA(http.HttpRequest),
new_flavor.name,
new_flavor.ram,
new_flavor.vcpus,
new_flavor.disk,
swap=new_flavor.swap,
ephemeral=eph,
is_public=new_flavor.is_public) \
.AndReturn(new_flavor)
new_flavor_projects = flavor_projects
for project in new_flavor_projects:
expect = api.nova.add_tenant_to_flavor(IsA(http.HttpRequest),
new_flavor.id, project.id)
if project == projects[0]:
expect.AndRaise(self.exceptions.nova)
# Put mocks in replay mode
self.mox.ReplayAll()
# run get test
url = reverse('horizon:admin:flavors:update', args=[flavor.id])
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assertTemplateUsed(resp, "admin/flavors/update.html")
# run post test
data = self._get_workflow_data(new_flavor, access=flavor_projects)
data['flavor_id'] = flavor.id
resp = self.client.post(url, data)
self.assertNoFormErrors(resp)
self.assertMessageCount(error=1, warning=0)
self.assertRedirectsNoFollow(resp, INDEX_URL)
def _test_usage(self, nova_stu_enabled=True, tenant_deleted=False):
self._stub_api_calls(nova_stu_enabled)
api.nova.extension_supported(
'SimpleTenantUsage', IsA(http.HttpRequest)) \
.AndReturn(nova_stu_enabled)
now = timezone.now()
usage_list = [api.nova.NovaUsage(u) for u in self.usages.list()]
if tenant_deleted:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([[self.tenants.first()], False])
else:
api.keystone.tenant_list(IsA(http.HttpRequest)) \
.AndReturn([self.tenants.list(), False])
if nova_stu_enabled:
api.nova.usage_list(IsA(http.HttpRequest),
datetime.datetime(now.year,
now.month,
1, 0, 0, 0, 0),
datetime.datetime(now.year,
now.month,
now.day, 23, 59, 59, 0)) \
.AndReturn(usage_list)
api.nova.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.limits['absolute'])
api.neutron.is_extension_supported(IsA(http.HttpRequest),
'security-group').AndReturn(True)
api.network.floating_ip_supported(IsA(http.HttpRequest)) \
.AndReturn(True)
api.network.tenant_floating_ip_list(IsA(http.HttpRequest)) \
.AndReturn(self.floating_ips.list())
api.network.security_group_list(IsA(http.HttpRequest)) \
.AndReturn(self.q_secgroups.list())
api.cinder.tenant_absolute_limits(IsA(http.HttpRequest)) \
.AndReturn(self.cinder_limits['absolute'])
self.mox.ReplayAll()
res = self.client.get(reverse('horizon:admin:overview:index'))
self.assertTemplateUsed(res, 'admin/overview/usage.html')
self.assertTrue(isinstance(res.context['usage'], usage.GlobalUsage))
self.assertEqual(nova_stu_enabled,
res.context['simple_tenant_usage_enabled'])
usage_table = encoding.smart_str(
u'''
<tr class="" data-object-id="1" id="global_usage__row__1">
<td class="sortable normal_column">test_tenant</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' %
(usage_list[0].vcpus,
sizeformat.diskgbformat(usage_list[0].disk_gb_hours),
sizeformat.mb_float_format(usage_list[0].memory_mb),
usage_list[0].vcpu_hours, usage_list[0].total_local_gb_usage))
# test for deleted project
usage_table_deleted = encoding.smart_str(
u'''
<tr class="" data-object-id="3" id="global_usage__row__3">
<td class="sortable normal_column">3 (Deleted)</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%s</td>
<td class="sortable normal_column">%.2f</td>
<td class="sortable normal_column">%.2f</td>
</tr>
''' %
(usage_list[1].vcpus,
sizeformat.diskgbformat(usage_list[1].disk_gb_hours),
sizeformat.mb_float_format(usage_list[1].memory_mb),
usage_list[1].vcpu_hours, usage_list[1].total_local_gb_usage))
if nova_stu_enabled:
self.assertContains(res, usage_table, html=True)
if tenant_deleted:
self.assertContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table_deleted, html=True)
else:
self.assertNotContains(res, usage_table, html=True)
def test_setup_should_throw_error_if_used_ratio_greater_than_one(self):
"""do_setup should throw error if nfs_used_ratio is greater than 1."""
drv = self._driver
self.configuration.nfs_used_ratio = 2
self.assertRaises(exception.NfsException, drv.do_setup,
IsA(context.RequestContext))
def test_create_simple_instance_exception(self):
trove_exception = self.exceptions.nova
api.trove.flavor_list(IsA(http.HttpRequest)).AndReturn(
self.flavors.list())
api.trove.backup_list(IsA(http.HttpRequest)).AndReturn(
self.database_backups.list())
# Mock datastores
api.trove.datastore_list(IsA(http.HttpRequest))\
.AndReturn(self.datastores.list())
# Mock datastore versions
api.trove.datastore_version_list(IsA(http.HttpRequest), IsA(str))\
.AndReturn(self.datastore_versions.list())
api.neutron.network_list(IsA(http.HttpRequest),
tenant_id=self.tenant.id,
shared=False).AndReturn(
self.networks.list()[:1])
api.neutron.network_list(IsA(http.HttpRequest),
shared=True).AndReturn(
self.networks.list()[1:])
nics = [{"net-id": self.networks.first().id, "v4-fixed-ip": ''}]
# Actual create database call
api.trove.instance_create(
IsA(http.HttpRequest),
IsA(unicode),
IsA(int),
IsA(unicode),
databases=None,
datastore=IsA(unicode),
datastore_version=IsA(unicode),
restore_point=None,
users=None,
nics=nics).AndRaise(trove_exception)
self.mox.ReplayAll()
post = {
'name': "MyDB",
'volume': '1',
'flavor': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'network': self.networks.first().id,
'datastore': 'mysql,5.5',
}
res = self.client.post(LAUNCH_URL, post)
self.assertRedirectsNoFollow(res, INDEX_URL)
def test_scheduleCronJob(self):
self.mock_thrift_client.scheduleCronJob(
IsA(JobConfiguration)).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().scheduleCronJob(JobConfiguration())
def test_correct_quotas_displayed(self):
servers = [s for s in self.servers.list()
if s.tenant_id == self.request.user.tenant_id]
api.base.is_service_enabled(IsA(http.HttpRequest), 'volume') \
.AndReturn(False)
api.base.is_service_enabled(IsA(http.HttpRequest), 'network') \
.MultipleTimes().AndReturn(True)
api.nova.tenant_quota_get(IsA(http.HttpRequest), '1') \
.AndReturn(self.quotas.first())
api.nova.flavor_list(IsA(http.HttpRequest)) \
.AndReturn(self.flavors.list())
search_opts = {'tenant_id': self.request.user.tenant_id}
api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts,
all_tenants=True) \
.AndReturn([servers, False])
api.neutron.is_extension_supported(
IsA(http.HttpRequest), 'security-group').AndReturn(True)
api.neutron.is_extension_supported(IsA(http.HttpRequest), 'quotas') \
.AndReturn(True)
api.neutron.tenant_quota_get(IsA(http.HttpRequest), self.tenant.id) \
.AndReturn(self.neutron_quotas.first())
api.neutron.router_list(IsA(http.HttpRequest)) \
.AndReturn(self.routers.list())
api.neutron.subnet_list(IsA(http.HttpRequest)) \
.AndReturn(self.subnets.list())
api.neutron.network_list(IsA(http.HttpRequest), shared=False) \
.AndReturn(self.networks.list())
api.network.floating_ip_supported(IsA(http.HttpRequest)) \
.AndReturn(True)
api.network.tenant_floating_ip_list(IsA(http.HttpRequest)) \
.MultipleTimes().AndReturn(self.floating_ips.list())
api.network.floating_ip_pools_list(IsA(http.HttpRequest)) \
.AndReturn(self.pools.list())
api.network.security_group_list(IsA(http.HttpRequest)) \
.AndReturn(self.security_groups.list())
self.mox.ReplayAll()
url = reverse('%s:allocate' % NAMESPACE)
res = self.client.get(url)
self.assertEqual(res.context['usages']['floating_ips']['quota'],
self.neutron_quotas.first().get('floatingip').limit)
def test_populateJobConfig(self): self.mock_thrift_client.populateJobConfig(IsA(JobConfiguration)).AndReturn(DEFAULT_RESPONSE) self.mox.ReplayAll() self.make_scheduler_proxy().populateJobConfig(JobConfiguration())
def test_restartShards(self):
self.mock_thrift_client.restartShards(
IsA(JobKey), IgnoreArg()).AndReturn(DEFAULT_RESPONSE)
self.mox.ReplayAll()
self.make_scheduler_proxy().restartShards(JOB_KEY, {0})
