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})