def _create_stack(template_string, stack_name=None, stack_id=None):
stack_name = stack_name or utils.random_name()
stack_id = stack_id or utils.random_name()
tpl = template.Template(template_format.parse(template_string))
ctx = utils.dummy_context()
ctx.tenant = 'test_tenant'
stack = stk.Stack(ctx, stack_name, tpl, disable_rollback=True)
with utils.UUIDStub(stack_id):
stack.store()
stack.create()
return stack
def _create_stack(template_string, stack_name=None,
stack_id=None):
stack_name = stack_name or utils.random_name()
stack_id = stack_id or utils.random_name()
tpl = template.Template(template_format.parse(template_string))
ctx = utils.dummy_context()
ctx.tenant = 'test_tenant'
stack = stk.Stack(ctx, stack_name, tpl, disable_rollback=True)
with utils.UUIDStub(stack_id):
stack.store()
stack.create()
return stack
def test_update_subnet_with_no_name(self):
stack_name = utils.random_name()
update_props = {'subnet': {
'name': None,
}}
update_props_name = {'subnet': {
'name': utils.PhysName(stack_name, 'test_subnet'),
}}
t, stack = self._test_subnet(stack_name, u_props=update_props_name)
self.patchobject(stack['net'], 'FnGetRefId',
return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766')
rsrc = self.create_subnet(t, stack, 'sub_net')
self.m.ReplayAll()
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIsNone(rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
rsrc.FnGetAtt('network_id'))
self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
update_snippet = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(),
update_props['subnet'])
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
self.m.VerifyAll()
def create_stack(self, stack_name=None, stack_id=None):
temp = template_format.parse(test_template_waitcondition)
template = tmpl.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
if stack_name is None:
stack_name = utils.random_name()
stack = parser.Stack(ctx, stack_name, template,
disable_rollback=True)
# Stub out the UUID for this test, so we can get an expected signature
if stack_id is not None:
with utils.UUIDStub(stack_id):
stack.store()
else:
stack.store()
self.stack_id = stack.id
# Stub waitcondition status so all goes CREATE_COMPLETE
with mock.patch.object(aws_wch.WaitConditionHandle,
'get_status') as m_gs:
m_gs.return_value = ['SUCCESS']
res_id = identifier.ResourceIdentifier('test_tenant', stack.name,
stack.id, '', 'WaitHandle')
with mock.patch.object(aws_wch.WaitConditionHandle,
'identifier') as m_id:
m_id.return_value = res_id
stack.create()
rsrc = stack['WaitHandle']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertEqual(rsrc.resource_id, rsrc.data().get('user_id'))
return stack
def create_stack(self, stack_name=None, stack_id=None):
temp = template_format.parse(test_template_waitcondition)
template = tmpl.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
if stack_name is None:
stack_name = utils.random_name()
stack = parser.Stack(ctx, stack_name, template, disable_rollback=True)
# Stub out the UUID for this test, so we can get an expected signature
if stack_id is not None:
with utils.UUIDStub(stack_id):
stack.store()
else:
stack.store()
self.stack_id = stack.id
# Stub waitcondition status so all goes CREATE_COMPLETE
with mock.patch.object(aws_wch.WaitConditionHandle,
'get_status') as m_gs:
m_gs.return_value = ['SUCCESS']
res_id = identifier.ResourceIdentifier('test_tenant', stack.name,
stack.id, '', 'WaitHandle')
with mock.patch.object(aws_wch.WaitConditionHandle,
'identifier') as m_id:
m_id.return_value = res_id
stack.create()
rsrc = stack['WaitHandle']
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
self.assertEqual(rsrc.resource_id, rsrc.data().get('user_id'))
return stack
def create_stack(self, stack_name=None, stack_id=None):
temp = template_format.parse(test_template_waitcondition)
template = parser.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
if stack_name is None:
stack_name = utils.random_name()
stack = parser.Stack(ctx, stack_name, template, disable_rollback=True)
# Stub out the UUID for this test, so we can get an expected signature
if stack_id is not None:
with utils.UUIDStub(stack_id):
stack.store()
else:
stack.store()
self.stack_id = stack.id
# Stub waitcondition status so all goes CREATE_COMPLETE
self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status')
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
# Stub keystone() with fake client
self.m.StubOutWithMock(wc.WaitConditionHandle, 'keystone')
wc.WaitConditionHandle.keystone().MultipleTimes().AndReturn(self.fc)
id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id,
'', 'WaitHandle')
self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier')
wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id)
self.m.ReplayAll()
stack.create()
return stack
def create_stack(self, stack_name=None, stack_id=None):
temp = template_format.parse(test_template_waitcondition)
template = parser.Template(temp)
ctx = utils.dummy_context(tenant_id='test_tenant')
if stack_name is None:
stack_name = utils.random_name()
stack = parser.Stack(ctx, stack_name, template,
disable_rollback=True)
# Stub out the UUID for this test, so we can get an expected signature
if stack_id is not None:
with utils.UUIDStub(stack_id):
stack.store()
else:
stack.store()
self.stack_id = stack.id
# Stub waitcondition status so all goes CREATE_COMPLETE
self.m.StubOutWithMock(wc.WaitConditionHandle, 'get_status')
wc.WaitConditionHandle.get_status().AndReturn(['SUCCESS'])
id = identifier.ResourceIdentifier('test_tenant', stack.name,
stack.id, '', 'WaitHandle')
self.m.StubOutWithMock(wc.WaitConditionHandle, 'identifier')
wc.WaitConditionHandle.identifier().MultipleTimes().AndReturn(id)
self.m.ReplayAll()
stack.create()
return stack
def create_file_based_template_resource(self):
test_template = '''
HeatTemplateFormatVersion: '2012-12-12'
Resources:
the_nested:
Type: the.yaml
Properties:
one: myname
'''
resource_template = '''
HeatTemplateFormatVersion: '2012-12-12'
Parameters:
one:
Type: String
Resources:
NestedResource:
Type: GenericResource
Outputs:
Foo:
Value: {Ref: one}
'''
utils.setup_dummy_db()
self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
tmpl = parser.Template(template_format.parse(test_template),
files={'the.yaml': resource_template})
self.stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
self.stack.store()
self.stack.create()
self.assertEqual(self.stack.state,
(self.stack.CREATE, self.stack.COMPLETE))
return self.stack
def create_file_based_template_resource(self):
test_template = '''
HeatTemplateFormatVersion: '2012-12-12'
Resources:
the_nested:
Type: the.yaml
Properties:
one: myname
'''
resource_template = '''
HeatTemplateFormatVersion: '2012-12-12'
Parameters:
one:
Type: String
Resources:
NestedResource:
Type: GenericResource
Outputs:
Foo:
Value: {Ref: one}
'''
utils.setup_dummy_db()
self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
resource._register_class('GenericResource',
generic_rsrc.GenericResource)
tmpl = parser.Template(template_format.parse(test_template),
files={'the.yaml': resource_template})
self.stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
self.stack.store()
self.stack.create()
self.assertEqual(self.stack.state, (self.stack.CREATE,
self.stack.COMPLETE))
return self.stack
def create_test_stack(self):
test_template = {'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {'Foo': {'Type': 'String'},
'Pass': {'Type': 'String',
'NoEcho': True}},
'Resources':
{'TestResource': {'Type': 'GenericResource',
'Properties': {'Foo': 'abc'}}},
'Outputs': {'food':
{'Value':
{'Fn::GetAtt': ['TestResource',
'foo']}}}}
template = parser.Template(test_template)
self.ctx = utils.dummy_context()
self.ctx.tenant_id = 'test_tenant'
env = environment.Environment()
env.load({u'parameters':
{u'Foo': 'user_data', u'Pass': '******'}})
self.stack_name = utils.random_name()
stack = parser.Stack(self.ctx, self.stack_name, template,
env=env, disable_rollback=True)
self.stack = stack
stack.store()
self.created_time = stack.created_time
self.create_at = timeutils.isotime(self.created_time)
stack.create()
self.expected = {}
for action in ('create', 'suspend', 'delete'):
self.make_mocks(action)
def create_stack(self, template=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(stack_user.StackUser, 'keystone')
stack_user.StackUser.keystone().MultipleTimes().AndReturn(
self.fc)
self.m.StubOutWithMock(alarm.CeilometerAlarm, 'ceilometer')
alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn(
self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def create_stack(self, template=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(alarm.CeilometerAlarm, 'ceilometer')
alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn(
self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
al['insufficient_data_actions'] = None
al['ok_actions'] = None
al['repeat_actions'] = True
al['enabled'] = True
al['evaluation_periods'] = 1
al['period'] = 60
al['threshold'] = 50
if 'matching_metadata' in al:
al['matching_metadata'] = dict(
('metadata.metering.%s' % k, v)
for k, v in al['matching_metadata'].items())
else:
al['matching_metadata'] = {}
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def test_update_subnet_with_no_name(self):
stack_name = utils.random_name()
update_props = {'subnet': {
'name': None,
}}
update_props_name = {'subnet': {
'name': utils.PhysName(stack_name, 'test_subnet'),
}}
t, stack = self._setup_mock(stack_name)
self.patchobject(stack['net'], 'FnGetRefId',
return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766')
rsrc = self.create_subnet(t, stack, 'sub_net')
scheduler.TaskRunner(rsrc.create)()
self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state)
rsrc.validate()
ref_id = rsrc.FnGetRefId()
self.assertEqual('91e47a57-7508-46fe-afc9-fc454e8580e1', ref_id)
self.assertIsNone(rsrc.FnGetAtt('network_id'))
self.assertEqual('fc68ea2c-b60b-4b4f-bd82-94ec81110766',
rsrc.FnGetAtt('network_id'))
self.assertEqual('8.8.8.8', rsrc.FnGetAtt('dns_nameservers')[0])
update_snippet = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(),
update_props['subnet'])
rsrc.handle_update(update_snippet, {}, update_props['subnet'])
self.update_mock.assert_called_once_with(
'91e47a57-7508-46fe-afc9-fc454e8580e1',
update_props_name
)
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
rsrc.state_set(rsrc.CREATE, rsrc.COMPLETE, 'to delete again')
self.assertIsNone(scheduler.TaskRunner(rsrc.delete)())
def create_stack(self, template=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(stack_user.StackUser, 'keystone')
stack_user.StackUser.keystone().MultipleTimes().AndReturn(
self.fc)
self.m.StubOutWithMock(alarm.CeilometerAlarm, 'ceilometer')
alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn(
self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def test_adopt(self):
data = {
'resources': {
u'the_nested': {
'resources': {
u'RealRandom': {
'resource_data': {
u'value': u'N8hE5C7ijdGn4RwnuygbAokGHnTq4cFJ'
},
'resource_id': 'N8hE5C7ijdGn4RwnuygbAokGHnTq4cFJ'
}
}
}
}
}
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.nested_tmpl})
stack = parser.Stack(self.ctx,
utils.random_name(),
tmpl,
adopt_stack_data=data)
self.stack = stack
stack.store()
stack.adopt()
self.assertEqual(('ADOPT', 'COMPLETE'), stack.state)
nested_res = data['resources']['the_nested']['resources']
self.assertEqual(nested_res['RealRandom']['resource_data']['value'],
stack.output('value'))
self.m.VerifyAll()
def create_test_stack(self):
test_template = {'HeatTemplateFormatVersion': '2012-12-12',
'Parameters': {'Foo': {'Type': 'String'},
'Pass': {'Type': 'String',
'NoEcho': True}},
'Resources':
{'TestResource': {'Type': 'GenericResource',
'Properties': {'Foo': 'abc'}}},
'Outputs': {'food':
{'Value':
{'Fn::GetAtt': ['TestResource',
'foo']}}}}
template = parser.Template(test_template)
self.ctx = utils.dummy_context()
self.ctx.tenant_id = 'test_tenant'
env = environment.Environment()
env.load({u'parameters':
{u'Foo': 'user_data', u'Pass': '******'}})
self.stack_name = utils.random_name()
stack = parser.Stack(self.ctx, self.stack_name, template,
env=env, disable_rollback=True)
self.stack = stack
stack.store()
self.created_time = stack.created_time
self.create_at = timeutils.isotime(self.created_time)
stack.create()
self.expected = {}
for action in ('create', 'suspend', 'delete'):
self.make_mocks(action)
def _assert_can_create(self, templ):
stack = parser.Stack(self.ctx, utils.random_name(),
template.Template(templ))
stack.store()
stack.create()
self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE),
stack.state)
return stack
def _assert_can_create(self, templ):
stack = parser.Stack(self.ctx, utils.random_name(),
template.Template(templ))
stack.store()
stack.create()
self.assertEqual((parser.Stack.CREATE, parser.Stack.COMPLETE),
stack.state)
return stack
def create_stack(self):
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.initial_tmpl})
stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
return stack
def create_stack(self):
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.initial_tmpl})
stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
return stack
def _create_dummy_stack(self, nested_templ):
env = environment.Environment()
env.load(yaml.load(self.env_templ))
templ = parser.Template(template_format.parse(self.main_templ),
files={'nested.yaml': nested_templ})
stack = parser.Stack(utils.dummy_context(),
utils.random_name(),
templ, env=env)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
return stack
def create_stack(self, template=None, time_constraints=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(ceilometer.CeilometerClientPlugin, '_create')
ceilometer.CeilometerClientPlugin._create().AndReturn(self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
al['insufficient_data_actions'] = None
al['ok_actions'] = None
al['repeat_actions'] = True
al['enabled'] = True
al['time_constraints'] = time_constraints if time_constraints else []
al['severity'] = 'low'
rule = dict(
period=60,
evaluation_periods=1,
threshold=50)
for field in ['period', 'evaluation_periods', 'threshold']:
del al[field]
for field in ['statistic', 'comparison_operator', 'meter_name']:
rule[field] = al[field]
del al[field]
if 'query' in al and al['query']:
query = al['query']
else:
query = []
if 'query' in al:
del al['query']
if 'matching_metadata' in al and al['matching_metadata']:
for k, v in al['matching_metadata'].items():
key = 'metadata.metering.' + k
query.append(dict(field=key, op='eq', value=six.text_type(v)))
if 'matching_metadata' in al:
del al['matching_metadata']
if query:
rule['query'] = mox.SameElementsAs(query)
al['threshold_rule'] = rule
al['type'] = 'threshold'
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def create_stack(self, template=None, time_constraints=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(ceilometer.CeilometerClientPlugin, '_create')
ceilometer.CeilometerClientPlugin._create().AndReturn(self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
al['insufficient_data_actions'] = None
al['ok_actions'] = None
al['repeat_actions'] = True
al['enabled'] = True
al['time_constraints'] = time_constraints if time_constraints else []
al['severity'] = 'low'
rule = dict(
period=60,
evaluation_periods=1,
threshold=50)
for field in ['period', 'evaluation_periods', 'threshold']:
del al[field]
for field in ['statistic', 'comparison_operator', 'meter_name']:
rule[field] = al[field]
del al[field]
if 'query' in al and al['query']:
query = al['query']
else:
query = []
if 'query' in al:
del al['query']
if 'matching_metadata' in al and al['matching_metadata']:
for k, v in al['matching_metadata'].items():
key = 'metadata.metering.' + k
query.append(dict(field=key, op='eq', value=six.text_type(v)))
if 'matching_metadata' in al:
del al['matching_metadata']
if query:
rule['query'] = query
al['threshold_rule'] = rule
al['type'] = 'threshold'
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def _mock_loadbalancer(self, lb_template, expected_name, expected_body):
t = template_format.parse(json.dumps(lb_template))
s = utils.parse_stack(t, stack_name=utils.random_name())
rsrc, fake_loadbalancer = self._mock_create(
s.t, s, self._get_first_resource_name(lb_template), expected_name,
expected_body)
self.m.StubOutWithMock(fake_loadbalancer, 'get')
fake_loadbalancer.get().MultipleTimes().AndReturn(None)
fake_loadbalancer.status = 'ACTIVE'
return (rsrc, fake_loadbalancer)
def test_abandon(self):
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.nested_tmpl})
stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
info = stack.prepare_abandon()
self.assertEqual(self._yaml_to_json(self.main_template),
info['template'])
self.assertEqual(self._yaml_to_json(self.nested_tmpl),
info['resources']['the_nested']['template'])
self.m.VerifyAll()
def test_abandon(self):
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.nested_tmpl})
stack = parser.Stack(self.ctx, utils.random_name(), tmpl)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
info = stack.prepare_abandon()
self.assertEqual(self._yaml_to_json(self.main_template),
info['template'])
self.assertEqual(self._yaml_to_json(self.nested_tmpl),
info['resources']['the_nested']['template'])
self.m.VerifyAll()
def create_stack(self, template=None):
if template is None:
template = event_alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant = "test_tenant"
stack = parser.Stack(ctx, utils.random_name(), template, disable_rollback=True)
stack.store()
self.patchobject(aodh.AodhClientPlugin, "_create").return_value = self.fa
self.patchobject(self.fa.alarm, "create").return_value = FakeAodhAlarm
return stack
def create_stack(self, template=None, time_constraints=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = "test_tenant"
stack = parser.Stack(ctx, utils.random_name(), template, disable_rollback=True)
stack.store()
self.m.StubOutWithMock(ceilometer.CeilometerClientPlugin, "_create")
ceilometer.CeilometerClientPlugin._create().AndReturn(self.fa)
al = copy.deepcopy(temp["Resources"]["MEMAlarmHigh"]["Properties"])
al["description"] = mox.IgnoreArg()
al["name"] = mox.IgnoreArg()
al["alarm_actions"] = mox.IgnoreArg()
al["insufficient_data_actions"] = None
al["ok_actions"] = None
al["repeat_actions"] = True
al["enabled"] = True
al["time_constraints"] = time_constraints if time_constraints else []
al["severity"] = "low"
rule = dict(period=60, evaluation_periods=1, threshold=50)
for field in ["period", "evaluation_periods", "threshold"]:
del al[field]
for field in ["statistic", "comparison_operator", "meter_name"]:
rule[field] = al[field]
del al[field]
if "query" in al and al["query"]:
query = al["query"]
else:
query = []
if "query" in al:
del al["query"]
if "matching_metadata" in al and al["matching_metadata"]:
for k, v in al["matching_metadata"].items():
key = "metadata.metering." + k
query.append(dict(field=key, op="eq", value=six.text_type(v)))
if "matching_metadata" in al:
del al["matching_metadata"]
if query:
rule["query"] = mox.SameElementsAs(query)
al["threshold_rule"] = rule
al["type"] = "threshold"
self.m.StubOutWithMock(self.fa.alarms, "create")
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def create_stack(self, template=None):
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.patchobject(aodh.AodhClientPlugin,
'_create').return_value = self.fa
self.patchobject(self.fa.alarm,
'create').return_value = FakeCompositeAlarm
return stack
def create_stack(self, template=None):
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.patchobject(aodh.AodhClientPlugin,
'_create').return_value = self.fa
self.patchobject(self.fa.alarm,
'create').return_value = FakeCompositeAlarm
return stack
def _mock_loadbalancer(self, lb_template, expected_name, expected_body):
t = template_format.parse(json.dumps(lb_template))
s = utils.parse_stack(t, stack_name=utils.random_name())
rsrc, fake_loadbalancer = self._mock_create(t, s,
self.
_get_first_resource_name(
lb_template),
expected_name,
expected_body)
self.m.StubOutWithMock(fake_loadbalancer, 'get')
fake_loadbalancer.get().MultipleTimes().AndReturn(None)
fake_loadbalancer.status = 'ACTIVE'
return (rsrc, fake_loadbalancer)
def create_stack(self, template=None, time_constraints=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant = "test_tenant"
stack = parser.Stack(ctx, utils.random_name(), template, disable_rollback=True)
stack.store()
self.patchobject(aodh.AodhClientPlugin, "_create").return_value = self.fa
al = copy.deepcopy(temp["Resources"]["MEMAlarmHigh"]["Properties"])
al["time_constraints"] = time_constraints if time_constraints else []
self.patchobject(self.fa.alarm, "create").return_value = FakeAodhAlarm
return stack
def create_autoscaling_stack_and_get_group(self):
env = environment.Environment()
env.load({u'parameters':
{u'KeyName': 'foo', 'ImageId': 'cloudimage'}})
t = template_format.parse(as_template)
template = parser.Template(t)
self.stack_name = utils.random_name()
stack = parser.Stack(self.ctx, self.stack_name, template,
env=env, disable_rollback=True)
stack.store()
self.created_time = stack.created_time
self.create_at = timeutils.isotime(self.created_time)
stack.create()
self.stack = stack
group = stack['WebServerGroup']
self.assertEqual((group.CREATE, group.COMPLETE), group.state)
return group
def test_no_infinite_recursion(self):
"""Prove that we can override a python resource.
And use that resource within the template resource.
"""
main_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: OS::Heat::RandomString
outputs:
secret1:
value: { get_attr: [secret1, value] }
'''
nested_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: OS::Heat::RandomString
outputs:
value:
value: { get_attr: [secret2, value] }
'''
env_templ = '''
resource_registry:
"OS::Heat::RandomString": nested.yaml
'''
env = environment.Environment()
env.load(yaml.load(env_templ))
templ = parser.Template(template_format.parse(main_templ),
files={'nested.yaml': nested_templ})
stack = parser.Stack(utils.dummy_context(),
utils.random_name(),
templ,
env=env)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
def create_stack(self, template=None, time_constraints=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = tmpl.Template(temp)
ctx = utils.dummy_context()
ctx.tenant = 'test_tenant'
stack = parser.Stack(ctx, utils.random_name(), template,
disable_rollback=True)
stack.store()
self.patchobject(aodh.AodhClientPlugin,
'_create').return_value = self.fa
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['time_constraints'] = time_constraints if time_constraints else []
self.patchobject(self.fa.alarm, 'create').return_value = FakeAodhAlarm
return stack
def create_stack(self, template=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = "test_tenant"
stack = parser.Stack(ctx, utils.random_name(), template, disable_rollback=True)
stack.store()
self.m.StubOutWithMock(alarm.CeilometerAlarm, "ceilometer")
alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn(self.fa)
al = copy.deepcopy(temp["Resources"]["MEMAlarmHigh"]["Properties"])
al["description"] = mox.IgnoreArg()
al["name"] = mox.IgnoreArg()
al["alarm_actions"] = mox.IgnoreArg()
self.m.StubOutWithMock(self.fa.alarms, "create")
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def test_no_infinite_recursion(self):
"""Prove that we can override a python resource.
And use that resource within the template resource.
"""
main_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: OS::Heat::RandomString
outputs:
secret1:
value: { get_attr: [secret1, value] }
'''
nested_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: OS::Heat::RandomString
outputs:
value:
value: { get_attr: [secret2, value] }
'''
env_templ = '''
resource_registry:
"OS::Heat::RandomString": nested.yaml
'''
env = environment.Environment()
env.load(yaml.load(env_templ))
templ = parser.Template(template_format.parse(main_templ),
files={'nested.yaml': nested_templ})
stack = parser.Stack(utils.dummy_context(),
utils.random_name(),
templ, env=env)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
def test_update_hot_empty_yaml(self):
t = template_format.parse('''
heat_template_version: 2013-05-23
parameters:
resources:
outputs:
''')
ut = template_format.parse('''
heat_template_version: 2013-05-23
parameters:
resources:
rand:
type: OS::Heat::RandomString
outputs:
''')
stack = self._assert_can_create(t)
updated = parser.Stack(self.ctx, utils.random_name(),
template.Template(ut))
stack.update(updated)
self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE),
stack.state)
def test_adopt(self):
data = {'resources': {u'the_nested': {
'resources': {u'RealRandom': {
'resource_data': {
u'value': u'N8hE5C7ijdGn4RwnuygbAokGHnTq4cFJ'},
'resource_id': 'N8hE5C7ijdGn4RwnuygbAokGHnTq4cFJ'}}}}}
t = template_format.parse(self.main_template)
tmpl = parser.Template(t, files={'the.yaml': self.nested_tmpl})
stack = parser.Stack(self.ctx, utils.random_name(), tmpl,
adopt_stack_data=data)
self.stack = stack
stack.store()
stack.adopt()
self.assertEqual(('ADOPT', 'COMPLETE'), stack.state)
nested_res = data['resources']['the_nested']['resources']
self.assertEqual(nested_res['RealRandom']['resource_data']['value'],
stack.output('value'))
self.m.VerifyAll()
def test_update_cfn_empty_yaml(self):
t = template_format.parse('''
AWSTemplateFormatVersion: 2010-09-09
Parameters:
Resources:
Outputs:
''')
ut = template_format.parse('''
AWSTemplateFormatVersion: 2010-09-09
Parameters:
Resources:
rand:
Type: OS::Heat::RandomString
Outputs:
''')
stack = self._assert_can_create(t)
updated = parser.Stack(self.ctx, utils.random_name(),
template.Template(ut))
stack.update(updated)
self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE),
stack.state)
def test_update_cfn_empty_yaml(self):
t = template_format.parse('''
AWSTemplateFormatVersion: 2010-09-09
Parameters:
Resources:
Outputs:
''')
ut = template_format.parse('''
AWSTemplateFormatVersion: 2010-09-09
Parameters:
Resources:
rand:
Type: OS::Heat::RandomString
Outputs:
''')
stack = self._assert_can_create(t)
updated = parser.Stack(self.ctx, utils.random_name(),
template.Template(ut))
stack.update(updated)
self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE),
stack.state)
def test_update_hot_empty_yaml(self):
t = template_format.parse('''
heat_template_version: 2013-05-23
parameters:
resources:
outputs:
''')
ut = template_format.parse('''
heat_template_version: 2013-05-23
parameters:
resources:
rand:
type: OS::Heat::RandomString
outputs:
''')
stack = self._assert_can_create(t)
updated = parser.Stack(self.ctx, utils.random_name(),
template.Template(ut))
stack.update(updated)
self.assertEqual((parser.Stack.UPDATE, parser.Stack.COMPLETE),
stack.state)
def test_nested_env(self):
main_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: My::NestedSecret
outputs:
secret1:
value: { get_attr: [secret1, value] }
'''
nested_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: My::Secret
outputs:
value:
value: { get_attr: [secret2, value] }
'''
env_templ = '''
resource_registry:
"My::Secret": "OS::Heat::RandomString"
"My::NestedSecret": nested.yaml
'''
env = environment.Environment()
env.load(yaml.load(env_templ))
templ = parser.Template(template_format.parse(main_templ),
files={'nested.yaml': nested_templ})
stack = parser.Stack(utils.dummy_context(),
utils.random_name(),
templ,
env=env)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
def create_test_stack(self):
test_template = {
"Parameters": {"Foo": {"Type": "String"}, "Pass": {"Type": "String", "NoEcho": True}},
"Resources": {"TestResource": {"Type": "GenericResource", "Properties": {"Foo": "abc"}}},
"Outputs": {"food": {"Value": {"Fn::GetAtt": ["TestResource", "foo"]}}},
}
template = parser.Template(test_template)
self.ctx = utils.dummy_context()
self.ctx.tenant_id = "test_tenant"
env = environment.Environment()
env.load({u"parameters": {u"Foo": "user_data", u"Pass": "******"}})
self.stack_name = utils.random_name()
stack = parser.Stack(self.ctx, self.stack_name, template, env=env, disable_rollback=True)
self.stack = stack
stack.store()
self.created_time = stack.created_time
self.create_at = timeutils.isotime(self.created_time)
stack.create()
self.expected = {}
for action in ("create", "suspend", "delete"):
self.make_mocks(action)
def test_nested_env(self):
main_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: My::NestedSecret
outputs:
secret1:
value: { get_attr: [secret1, value] }
'''
nested_templ = '''
heat_template_version: 2013-05-23
resources:
secret2:
type: My::Secret
outputs:
value:
value: { get_attr: [secret2, value] }
'''
env_templ = '''
resource_registry:
"My::Secret": "OS::Heat::RandomString"
"My::NestedSecret": nested.yaml
'''
env = environment.Environment()
env.load(yaml.load(env_templ))
templ = parser.Template(template_format.parse(main_templ),
files={'nested.yaml': nested_templ})
stack = parser.Stack(utils.dummy_context(),
utils.random_name(),
templ, env=env)
stack.store()
stack.create()
self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state)
def create_stack(self, template=None):
if template is None:
template = alarm_template
temp = template_format.parse(template)
template = parser.Template(temp)
ctx = utils.dummy_context()
ctx.tenant_id = 'test_tenant'
stack = parser.Stack(ctx,
utils.random_name(),
template,
disable_rollback=True)
stack.store()
self.m.StubOutWithMock(alarm.CeilometerAlarm, 'ceilometer')
alarm.CeilometerAlarm.ceilometer().MultipleTimes().AndReturn(self.fa)
al = copy.deepcopy(temp['Resources']['MEMAlarmHigh']['Properties'])
al['description'] = mox.IgnoreArg()
al['name'] = mox.IgnoreArg()
al['alarm_actions'] = mox.IgnoreArg()
al['insufficient_data_actions'] = None
al['ok_actions'] = None
al['repeat_actions'] = True
al['enabled'] = True
al['evaluation_periods'] = 1
al['period'] = 60
al['threshold'] = 50
if 'matching_metadata' in al:
al['matching_metadata'] = dict(
('metadata.metering.%s' % k, v)
for k, v in al['matching_metadata'].items())
else:
al['matching_metadata'] = {}
self.m.StubOutWithMock(self.fa.alarms, 'create')
self.fa.alarms.create(**al).AndReturn(FakeCeilometerAlarm())
return stack
def setUp(self):
super(UserTest, self).setUp()
self.stack_name = 'test_user_stack_%s' % utils.random_name()
self.username = '******' % self.stack_name
self.fc = fakes.FakeKeystoneClient(username=self.username)
cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
def setUp(self):
super(UserTest, self).setUp()
self.stack_name = 'test_user_stack_%s' % utils.random_name()
self.username = '******' % self.stack_name
self.fc = fakes.FakeKeystoneClient(username=self.username)
cfg.CONF.set_default('heat_stack_user_role', 'stack_user_role')
