def create_firewall_policy(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_firewall_policy({
'firewall_policy': {
'name': 'test-firewall-policy', 'shared': True,
'audited': True, 'firewall_rules': ['rule-id-1', 'rule-id-2']}}
).AndReturn({'firewall_policy': {'id': '5678'}})
snippet = template_format.parse(firewall_policy_template)
stack = utils.parse_stack(snippet)
return firewall.FirewallPolicy(
'firewall_policy', snippet['Resources']['firewall_policy'], stack)
def create_ipsec_site_connection(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_ipsec_site_connection(
self.IPSEC_SITE_CONNECTION_CONF).AndReturn(
{'ipsec_site_connection': {
'id': 'con123'
}})
snippet = template_format.parse(ipsec_site_connection_template)
self.stack = utils.parse_stack(snippet)
return vpnservice.IPsecSiteConnection(
'ipsec_site_connection',
snippet['Resources']['IPsecSiteConnection'], self.stack)
def create_health_monitor(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_health_monitor({
'health_monitor': {
'delay': 3, 'max_retries': 5, 'type': u'HTTP',
'timeout': 10, 'admin_state_up': True}}
).AndReturn({'health_monitor': {'id': '5678'}})
snippet = template_format.parse(health_monitor_template)
stack = utils.parse_stack(snippet)
return loadbalancer.HealthMonitor(
'monitor', snippet['Resources']['monitor'], stack)
def create_ipsecpolicy(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_ipsecpolicy(
self.IPSEC_POLICY_CONF).AndReturn(
{'ipsecpolicy': {
'id': 'ips123'
}})
snippet = template_format.parse(ipsecpolicy_template)
self.stack = utils.parse_stack(snippet)
return vpnservice.IPsecPolicy('ipsecpolicy',
snippet['Resources']['IPsecPolicy'],
self.stack)
def setUp(self):
super(LoadBalancerTest, self).setUp()
config.register_engine_opts()
self.fc = fakes.FakeClient()
self.m.StubOutWithMock(clients.OpenStackClients, 'nova')
self.m.StubOutWithMock(self.fc.servers, 'create')
self.m.StubOutWithMock(Metadata, '__set__')
self.fkc = test_fakes.FakeKeystoneClient(
username='******')
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://127.0.0.1:8000/v1/waitcondition')
setup_dummy_db()
def create_metering_label(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_metering_label({
'metering_label': {
'name': 'TestLabel',
'description': 'Description of TestLabel'}
}).AndReturn({'metering_label': {'id': '1234'}})
snippet = template_format.parse(metering_template)
stack = utils.parse_stack(snippet)
return metering.MeteringLabel(
'label', snippet['Resources']['label'], stack)
def create_member(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_member({
'member': {
'pool_id': 'pool123', 'protocol_port': 8080,
'address': '1.2.3.4', 'admin_state_up': True}}
).AndReturn({'member': {'id': 'member5678'}})
snippet = template_format.parse(member_template)
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
return loadbalancer.PoolMember(
'member', resource_defns['member'], stack)
def setUp(self):
super(SignalTest, self).setUp()
resource._register_class('SignalResourceType',
generic_resource.SignalResource)
resource._register_class('GenericResourceType',
generic_resource.GenericResource)
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://server.test:8000/v1/waitcondition')
self.stack_id = 'STACKABCD1234'
self.fc = fakes.FakeKeystoneClient()
def create_firewall(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_firewall({
'firewall': {
'name': 'test-firewall', 'admin_state_up': True,
'firewall_policy_id': 'policy-id'}}
).AndReturn({'firewall': {'id': '5678'}})
snippet = template_format.parse(firewall_template)
stack = utils.parse_stack(snippet)
return firewall.Firewall(
'firewall', snippet['Resources']['firewall'], stack)
def test_create_failed_unexpected_vip_status(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutron.neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'subnet',
'sub123').AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub123',
'pool_id': '5678',
'protocol_port': 80
}
}).AndReturn({'vip': {
'id': 'xyz'
}})
neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ERROR',
'name': 'xyz'
}})
snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet)
rsrc = loadbalancer.Pool('pool', snippet['Resources']['pool'], stack)
self.m.ReplayAll()
error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual(
'Error: neutron reported unexpected vip '
'resource[xyz] status[ERROR]', str(error))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def setUp(self):
super(RollingUpdatesTest, self).setUp()
utils.setup_dummy_db()
resource._register_class('ResourceWithProps',
generic_resource.ResourceWithProps)
cfg.CONF.set_default('heat_waitcondition_server_url',
'http://server.test:8000/v1/waitcondition')
self.fc = fakes.FakeKeystoneClient()
client = self.patchobject(clients.OpenStackClients, "keystone")
client.return_value = self.fc
self.parsed = template_format.parse(self.as_template)
generate_id = self.patchobject(short_id, 'generate_id')
generate_id.side_effect = ('id-%d' % (i, )
for i in itertools.count()).next
def create_load_balancer(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc)
neutronclient.Client.create_member({
'member': {
'pool_id': 'pool123', 'protocol_port': 8080,
'address': '1.2.3.4'}}
).AndReturn({'member': {'id': 'member5678'}})
snippet = template_format.parse(lb_template)
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
return loadbalancer.LoadBalancer(
'lb', resource_defns['lb'], stack)
def test_create_with_session_persistence(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutron_utils.neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client), 'subnet',
'sub123').AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub123',
'pool_id': '5678',
'protocol_port': 80,
'session_persistence': {
'type': 'APP_COOKIE',
'cookie_name': 'cookie'
}
}
}).AndReturn({'vip': {
'id': 'xyz'
}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ACTIVE'
}})
snippet = template_format.parse(pool_with_session_persistence_template)
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
rsrc = loadbalancer.Pool('pool', resource_defns['pool'], stack)
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def prepare_create_network_gateway(self, resolve_neutron=True):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_network_gateway({
'network_gateway': {
'name': u'NetworkGateway',
'devices': [{'id': u'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': u'breth1'}]
}
}
).AndReturn({
'network_gateway': {
'id': 'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'name': 'NetworkGateway',
'default': False,
'tenant_id': '96ba52dc-c5c5-44c6-9a9d-d3ba1a03f77f',
'devices': [{
'id': 'e52148ca-7db9-4ec3-abe6-2c7c0ff316eb',
'interface_name': 'breth1'}]
}
}
)
neutronclient.Client.connect_network_gateway(
u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37', {
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'segmentation_id': 10,
'segmentation_type': u'vlan'
}
).AndReturn({
'connection_info': {
'network_gateway_id': u'ed4c03b9-8251-4c09-acc4-e59ee9e6aa37',
'network_id': u'6af055d3-26f6-48dd-a597-7611d7e58d35',
'port_id': u'32acc49c-899e-44ea-8177-6f4157e12eb4'
}
})
if resolve_neutron:
neutron.neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'network',
'6af055d3-26f6-48dd-a597-7611d7e58d35'
).AndReturn('6af055d3-26f6-48dd-a597-7611d7e58d35')
t = template_format.parse(gw_template)
else:
t = template_format.parse(gw_template_deprecated)
stack = utils.parse_stack(t)
rsrc = network_gateway.NetworkGateway(
'test_network_gateway',
t['Resources']['NetworkGateway'], stack)
return rsrc
def test_create_pending(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123',
'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN',
'admin_state_up': True
}
}).AndReturn({'pool': {
'id': '5678'
}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP',
'name': 'pool.vip',
'admin_state_up': True,
'subnet_id': u'sub123',
'pool_id': '5678',
'protocol_port': 80
}
}).AndReturn({'vip': {
'id': 'xyz'
}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {
'status': 'PENDING_CREATE'
}})
neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn(
{'pool': {
'status': 'ACTIVE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'PENDING_CREATE'
}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {
'status': 'ACTIVE'
}})
snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet)
rsrc = loadbalancer.Pool('pool', snippet['Resources']['pool'], stack)
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def create_firewall_rule(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_firewall_rule({
'firewall_rule': {
'name': 'test-firewall-rule', 'shared': True,
'action': 'allow', 'protocol': 'tcp', 'enabled': True,
'ip_version': "4"}}
).AndReturn({'firewall_rule': {'id': '5678'}})
snippet = template_format.parse(firewall_rule_template)
stack = utils.parse_stack(snippet)
return firewall.FirewallRule(
'firewall_rule', snippet['Resources']['firewall_rule'], stack)
def setUp(self):
super(KeystoneEndpointTest, self).setUp()
self.ctx = utils.dummy_context()
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(resource.Resource, 'client',
return_value=fakes.FakeKeystoneClient(
client=self.keystoneclient))
self.endpoints = self.keystoneclient.endpoints
# Mock client plugin
self.keystone_client_plugin = mock.MagicMock()
def create_metering_label_rule(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_metering_label_rule({
'metering_label_rule': {
'metering_label_id': 'None',
'remote_ip_prefix': '10.0.3.0/24',
'direction': 'ingress',
'excluded': False}
}).AndReturn({'metering_label_rule': {'id': '5678'}})
snippet = template_format.parse(metering_template)
stack = utils.parse_stack(snippet)
return metering.MeteringRule(
'rule', snippet['Resources']['rule'], stack)
def test_properties_are_prepared_for_session_persistence(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutron_utils.neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123'
).AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123', 'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
).AndReturn({'pool': {'id': '5678'}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP', 'name': 'pool.vip',
'admin_state_up': True, 'subnet_id': u'sub123',
'pool_id': '5678', 'protocol_port': 80,
'session_persistence': {'type': 'HTTP_COOKIE'}}}
).AndReturn({'vip': {'id': 'xyz'}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {'status': 'ACTIVE'}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {'status': 'ACTIVE'}})
snippet = template_format.parse(pool_with_session_persistence_template)
pool = snippet['Resources']['pool']
persistence = pool['Properties']['vip']['session_persistence']
# change persistence type to HTTP_COOKIE that not require cookie_name
persistence['type'] = 'HTTP_COOKIE'
del persistence['cookie_name']
stack = utils.parse_stack(snippet)
resource_defns = stack.t.resource_definitions(stack)
resource = loadbalancer.Pool('pool', resource_defns['pool'], stack)
# assert that properties contain cookie_name property with None value
persistence = resource.properties['vip']['session_persistence']
self.assertIn('cookie_name', persistence)
self.assertIsNone(persistence['cookie_name'])
self.m.ReplayAll()
scheduler.TaskRunner(resource.create)()
self.assertEqual((resource.CREATE, resource.COMPLETE), resource.state)
self.m.VerifyAll()
def test_delete_exception(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(container_name,
{}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndRaise(
swiftclient.ClientException('Test delete failure'))
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'SwiftContainer')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_update_monitors(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutron_utils.neutronV20.find_resourceid_by_name_or_id(
mox.IsA(neutronclient.Client),
'subnet',
'sub123'
).AndReturn('sub123')
neutronclient.Client.create_pool({
'pool': {
'subnet_id': 'sub123', 'protocol': u'HTTP',
'name': utils.PhysName('test_stack', 'pool'),
'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}}
).AndReturn({'pool': {'id': '5678'}})
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {'id': 'mon123'}})
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {'id': 'mon456'}})
neutronclient.Client.create_vip({
'vip': {
'protocol': u'HTTP', 'name': 'pool.vip',
'admin_state_up': True, 'subnet_id': u'sub123',
'pool_id': '5678', 'protocol_port': 80}}
).AndReturn({'vip': {'id': 'xyz'}})
neutronclient.Client.show_pool('5678').AndReturn(
{'pool': {'status': 'ACTIVE'}})
neutronclient.Client.show_vip('xyz').AndReturn(
{'vip': {'status': 'ACTIVE'}})
neutronclient.Client.disassociate_health_monitor(
'5678', 'mon456')
neutronclient.Client.associate_health_monitor(
'5678', {'health_monitor': {'id': 'mon789'}})
snippet = template_format.parse(pool_template)
stack = utils.parse_stack(snippet)
snippet['Resources']['pool']['Properties']['monitors'] = [
'mon123', 'mon456']
resource_defns = stack.t.resource_definitions(stack)
rsrc = loadbalancer.Pool('pool', resource_defns['pool'], stack)
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
update_template = copy.deepcopy(rsrc.t)
update_template['Properties']['monitors'] = ['mon123', 'mon789']
scheduler.TaskRunner(rsrc.update, update_template)()
self.m.VerifyAll()
def setUp(self):
super(KeystoneGroupRoleAssignmentTest, self).setUp()
self.ctx = utils.dummy_context()
self.stack = stack.Stack(
self.ctx, 'test_stack_keystone_group_role_add',
template.Template(self.role_assignment_template))
self.test_role_assignment = self.stack['test_role_assignment']
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(
resource.Resource,
'client',
return_value=fakes.FakeKeystoneClient(client=self.keystoneclient))
self.roles = self.keystoneclient.roles
# Mock client plugin
def _side_effect(value):
return value
self.keystone_client_plugin = mock.MagicMock()
self.keystone_client_plugin.get_group_id.side_effect = _side_effect
self.keystone_client_plugin.get_domain_id.side_effect = _side_effect
self.keystone_client_plugin.get_role_id.side_effect = _side_effect
self.keystone_client_plugin.get_project_id.side_effect = _side_effect
self.test_role_assignment.client_plugin = mock.MagicMock()
(self.test_role_assignment.client_plugin.return_value
) = self.keystone_client_plugin
self.test_role_assignment.parse_list_assignments = mock.MagicMock()
self.test_role_assignment.parse_list_assignments.return_value = [{
'role':
'role_1',
'domain':
'domain_1',
'project':
None
}, {
'role':
'role_1',
'project':
'project_1',
'domain':
None
}]
def setUp(self):
super(KeystoneRoleTest, self).setUp()
self.ctx = utils.dummy_context()
self.stack = stack.Stack(self.ctx, 'test_stack_keystone',
template.Template(keystone_role_template))
self.test_role = self.stack['test_role']
# Mock client
self.keystoneclient = mock.Mock()
self.patchobject(
resource.Resource,
'client',
return_value=fakes.FakeKeystoneClient(client=self.keystoneclient))
self.roles = self.keystoneclient.roles
def test_attributes(self):
headers = {
"content-length": "0",
"x-container-object-count": "82",
"accept-ranges": "bytes",
"x-trans-id": "tx08ea48ef2fa24e6da3d2f5c188fd938b",
"date": "Wed, 23 Jan 2013 22:48:05 GMT",
"x-timestamp": "1358980499.84298",
"x-container-read": ".r:*",
"x-container-bytes-used": "17680980",
"content-type": "text/plain; charset=utf-8"
}
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(container_name,
{}).AndReturn(None)
swiftclient.Connection.head_container(
mox.IgnoreArg()).MultipleTimes().AndReturn(headers)
swiftclient.Connection.delete_container(container_name).AndReturn(None)
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'SwiftContainer')
ref_id = rsrc.FnGetRefId()
self.assertEqual(container_name, ref_id)
self.assertEqual('example.com', rsrc.FnGetAtt('DomainName'))
url = 'http://example.com:1234/v1/%s' % ref_id
self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL'))
self.assertEqual('82', rsrc.FnGetAtt('ObjectCount'))
self.assertEqual('17680980', rsrc.FnGetAtt('BytesUsed'))
self.assertEqual(headers, rsrc.FnGetAtt('HeadContainer'))
self.assertRaises(swift.exception.InvalidTemplateAttribute,
rsrc.FnGetAtt, 'Foo')
self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {},
{})
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_public_read(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(container_name, {
'X-Container-Read': '.r:*'
}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndReturn(None)
self.m.ReplayAll()
t = template_format.parse(swift_template)
properties = t['Resources']['SwiftContainer']['Properties']
properties['X-Container-Read'] = '.r:*'
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'SwiftContainer')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_account_headers(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(container_name, {})
swiftclient.Connection.post_account({
'X-Account-Meta-Temp-Url-Key':
'secret'
}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndReturn(None)
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'SwiftAccountMetadata')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_website(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(
container_name,
{'X-Container-Meta-Web-Error': 'error.html',
'X-Container-Meta-Web-Index': 'index.html',
'X-Container-Write': 'test_tenant:test_username',
'X-Container-Read': '.r:*'}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndReturn(None)
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'S3BucketWebsite')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_authenticated_read(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(
container_name,
{'X-Container-Write': 'test_tenant:test_username',
'X-Container-Read': 'test_tenant'}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndReturn(None)
self.m.ReplayAll()
t = template_format.parse(swift_template)
properties = t['Resources']['S3Bucket']['Properties']
properties['AccessControl'] = 'AuthenticatedRead'
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'S3Bucket')
scheduler.TaskRunner(rsrc.delete)()
self.m.VerifyAll()
def test_create_failed(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
neutronclient.Client.create_ikepolicy(self.IKE_POLICY_CONF).AndRaise(
vpnservice.NeutronClientException())
self.m.ReplayAll()
snippet = template_format.parse(ikepolicy_template)
self.stack = utils.parse_stack(snippet)
rsrc = vpnservice.IKEPolicy('ikepolicy',
snippet['Resources']['IKEPolicy'],
self.stack)
error = self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual(
'NeutronClientException: An unknown exception occurred.',
str(error))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
self.m.VerifyAll()
def test_delete_exception(self):
clients.OpenStackClients.keystone().AndReturn(
fakes.FakeKeystoneClient())
container_name = utils.PhysName('test_stack', 'test_resource')
swiftclient.Connection.put_container(
container_name,
{'X-Container-Write': 'test_tenant:test_username',
'X-Container-Read': 'test_tenant:test_username'}).AndReturn(None)
swiftclient.Connection.delete_container(container_name).AndRaise(
swiftclient.ClientException('Test delete failure'))
self.m.ReplayAll()
t = template_format.parse(swift_template)
stack = utils.parse_stack(t)
rsrc = self.create_resource(t, stack, 'S3Bucket')
rsrc.delete()
self.m.VerifyAll()
