def test_delete_trust_not_trustor(self): # Stack gets created with trustor_ctx, deleted with other_ctx # then the trust delete should be with stored_ctx trustor_ctx = utils.dummy_context(user_id="thetrustor") other_ctx = utils.dummy_context(user_id="nottrustor") stored_ctx = utils.dummy_context(trust_id="thetrust") mock_kc = self.patchobject(hkc, "KeystoneClient") self.stub_keystoneclient(user_id="thetrustor") mock_sc = self.patchobject(stack.Stack, "stored_context") mock_sc.return_value = stored_ctx self.stack = stack.Stack(trustor_ctx, "delete_trust_nt", self.tmpl) stack_id = self.stack.store() db_s = stack_object.Stack.get_by_id(self.ctx, stack_id) self.assertIsNotNone(db_s) user_creds_id = db_s.user_creds_id self.assertIsNotNone(user_creds_id) user_creds = ucreds_object.UserCreds.get_by_id(self.ctx, user_creds_id) self.assertEqual("thetrustor", user_creds.get("trustor_user_id")) mock_kc.return_value = fakes.FakeKeystoneClient(user_id="nottrustor") loaded_stack = stack.Stack.load(other_ctx, self.stack.id) loaded_stack.delete() mock_sc.assert_called_with() db_s = stack_object.Stack.get_by_id(other_ctx, stack_id) self.assertIsNone(db_s) self.assertEqual((stack.Stack.DELETE, stack.Stack.COMPLETE), loaded_stack.state)
def test_purge_deleted(self): now = datetime.now() delta = timedelta(seconds=3600 * 7) deleted = [now - delta * i for i in range(1, 6)] templates = [create_raw_template(self.ctx) for i in range(5)] creds = [create_user_creds(self.ctx) for i in range(5)] stacks = [create_stack(self.ctx, templates[i], creds[i], deleted_at=deleted[i]) for i in range(5)] class MyDatetime(): def now(self): return now self.useFixture(fixtures.MonkeyPatch('heat.db.sqlalchemy.api.datetime', MyDatetime())) db_api.purge_deleted(age=1, granularity='days') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1, 2), (3, 4)) db_api.purge_deleted(age=22, granularity='hours') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1, 2), (3, 4)) db_api.purge_deleted(age=1100, granularity='minutes') self._deleted_stack_existance(utils.dummy_context(), stacks, (0, 1), (2, 3, 4)) db_api.purge_deleted(age=3600, granularity='seconds') self._deleted_stack_existance(utils.dummy_context(), stacks, (), (0, 1, 2, 3, 4))
def test_sync_with_time_throttle(self): ctx = utils.dummy_context() stack = tools.get_stack('test_stack', utils.dummy_context(), template=tools.string_template_five, convergence=True) stack.converge_stack(stack.t, action=stack.CREATE) mock_sleep_time = self.sync_with_sleep(ctx, stack) mock_sleep_time.assert_called_once_with(mock.ANY)
def test_stack_create_no_credentials(self): cfg.CONF.set_default('deferred_auth_method', 'password') stack_name = 'test_stack_create_no_credentials' params = {'foo': 'bar'} template = '{ "Template": "data" }' stk = tools.get_stack(stack_name, self.ctx) # force check for credentials on create stk['WebServer'].requires_deferred_auth = True mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t) mock_env = self.patchobject(environment, 'Environment', return_value=stk.env) mock_stack = self.patchobject(stack, 'Stack', return_value=stk) # test stack create using context without password ctx_no_pwd = utils.dummy_context(password=None) ex = self.assertRaises(dispatcher.ExpectedException, self.man.create_stack, ctx_no_pwd, stack_name, template, params, None, {}, None) self.assertEqual(exception.MissingCredentialError, ex.exc_info[0]) self.assertEqual('Missing required credential: X-Auth-Key', six.text_type(ex.exc_info[1])) mock_tmpl.assert_called_once_with(template, files=None, env=stk.env) mock_env.assert_called_once_with(params) mock_stack.assert_called_once_with(ctx_no_pwd, stack_name, stk.t, owner_id=None, nested_depth=0, user_creds_id=None, stack_user_project_id=None, convergence=False, parent_resource=None) mock_tmpl.reset_mock() mock_env.reset_mock() mock_stack.reset_mock() # test stack create using context without user ctx_no_pwd = utils.dummy_context(password=None) ctx_no_user = utils.dummy_context(user=None) ex = self.assertRaises(dispatcher.ExpectedException, self.man.create_stack, ctx_no_user, stack_name, template, params, None, {}) self.assertEqual(exception.MissingCredentialError, ex.exc_info[0]) self.assertEqual('Missing required credential: X-Auth-User', six.text_type(ex.exc_info[1])) mock_tmpl.assert_called_once_with(template, files=None, env=stk.env) mock_env.assert_called_once_with(params) mock_stack.assert_called_once_with(ctx_no_user, stack_name, stk.t, owner_id=None, nested_depth=0, user_creds_id=None, stack_user_project_id=None, convergence=False, parent_resource=None)
def test_check_admin(self): enforcer = policy.Enforcer() ctx = utils.dummy_context(roles=[]) self.assertFalse(enforcer.check_is_admin(ctx)) ctx = utils.dummy_context(roles=['not_admin']) self.assertFalse(enforcer.check_is_admin(ctx)) ctx = utils.dummy_context(roles=['admin']) self.assertTrue(enforcer.check_is_admin(ctx))
def test_updated_time(self, mock_cr): stack = parser.Stack(utils.dummy_context(), 'convg_updated_time_test', templatem.Template.create_empty_template()) stack.store() stack.create() self.assertIsNone(stack.updated_time) tmpl = {'HeatTemplateFormatVersion': '2012-12-12', 'Resources': {'R1': {'Type': 'GenericResourceType'}}} newstack = parser.Stack(utils.dummy_context(), 'updated_time_test', templatem.Template(tmpl)) stack.update(newstack) self.assertIsNotNone(stack.updated_time)
def test_resource_facade_missing_deletion_policy(self): snippet = {"resource_facade": "deletion_policy"} class DummyClass(object): pass parent_resource = DummyClass() parent_resource.metadata = {"foo": "bar"} parent_resource.t = {} parent_resource.stack = parser.Stack(utils.dummy_context(), "toplevel_stack", parser.Template({})) stack = parser.Stack( utils.dummy_context(), "test_stack", parser.Template(hot_tpl_empty), parent_resource=parent_resource ) self.assertEqual("Delete", self.resolve(snippet, stack.t, stack))
def test_nested_stack_delete_then_delete_parent_stack(self): urlfetch.get("https://server.test/the.template").MultipleTimes().AndReturn(self.nested_template) self.m.ReplayAll() stack = self.create_stack(self.test_template) rsrc = stack["the_nested"] nested_stack = parser.Stack.load(utils.dummy_context("test_username", "aaaa", "password"), rsrc.resource_id) nested_stack.delete() stack = parser.Stack.load(utils.dummy_context("test_username", "aaaa", "password"), stack.id) stack.delete() self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state) self.m.VerifyAll()
def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, {}, stack_id=uuidutils.generate_uuid()) return (t, stack)
def create_stack(self, stack_id=None, template=test_template_heat_waitcondition_count, params={}, stub=True, stub_status=True): temp = template_format.parse(template) template = parser.Template(temp) ctx = utils.dummy_context(tenant_id=self.tenant_id) stack = parser.Stack(ctx, 'test_stack', template, environment.Environment(params), disable_rollback=True) # Stub out the stack ID so we have a known value if stack_id is None: stack_id = str(uuid.uuid4()) self.stack_id = stack_id with utils.UUIDStub(self.stack_id): stack.store() if stub: id = identifier.ResourceIdentifier('test_tenant', stack.name, stack.id, '', 'wait_handle') self.m.StubOutWithMock(wc.HeatWaitConditionHandle, 'identifier') wc.HeatWaitConditionHandle.identifier().MultipleTimes().AndReturn( id) if stub_status: self.m.StubOutWithMock(wc.HeatWaitConditionHandle, 'get_status') return stack
def test_format_stack_outputs(self): template = parser.Template({ 'HeatTemplateFormatVersion': '2012-12-12', 'Resources': { 'generic': {'Type': 'GenericResourceType'} }, 'Outputs': { 'correct_output': { 'Description': 'Good output', 'Value': {'Fn::GetAtt': ['generic', 'Foo']} }, 'incorrect_output': { 'Value': {'Fn::GetAtt': ['generic', 'Bar']} } } }) stack = parser.Stack(utils.dummy_context(), 'test_stack', template, stack_id=str(uuid.uuid4())) stack.action = 'CREATE' stack.status = 'COMPLETE' stack['generic'].action = 'CREATE' stack['generic'].status = 'COMPLETE' info = api.format_stack_outputs(stack, stack.outputs) expected = [{'description': 'No description given', 'output_error': 'The Referenced Attribute (generic Bar) ' 'is incorrect.', 'output_key': 'incorrect_output', 'output_value': None}, {'description': 'Good output', 'output_key': 'correct_output', 'output_value': 'generic'}] self.assertEqual(expected, info)
def test_validate(self): mock_extension = self.patchobject( neutron.NeutronClientPlugin, 'has_extension', return_value=True) nc = mock.Mock() mock_create = self.patchobject(neutron.NeutronClientPlugin, '_create') mock_create.return_value = nc mock_find = self.patchobject(neutron.NeutronClientPlugin, 'find_resourceid_by_name_or_id') mock_find.side_effect = [ 'foo', qe.NeutronClientException(status_code=404) ] constraint = self.constraint_class() ctx = utils.dummy_context() if hasattr(constraint, 'extension') and constraint.extension: mock_extension.side_effect = [ False, True, True, ] ex = self.assertRaises( exception.EntityNotFound, constraint.validate_with_client, ctx.clients, "foo" ) expected = ("The neutron extension (%s) could not be found." % constraint.extension) self.assertEqual(expected, six.text_type(ex)) self.assertTrue(constraint.validate("foo", ctx)) self.assertFalse(constraint.validate("bar", ctx)) mock_find.assert_has_calls( [mock.call(self.resource_type, 'foo', cmd_resource=self.cmd_resource), mock.call(self.resource_type, 'bar', cmd_resource=self.cmd_resource)])
def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.validate() stack.store() 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 test_user_template_retrieve_fail(self): # make sure that a TemplateResource defined in the user environment # fails gracefully if the template file specified is inaccessible # we should be able to create the TemplateResource object, but # validation should fail, when the second attempt to access it is # made in validate() env = environment.Environment() test_templ_name = 'http://heatr/noexist.yaml' env.load({'resource_registry': {'Test::Flippy': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template), env=env, stack_id=str(uuid.uuid4())) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https'))\ .AndRaise(urlfetch.URLFetchError(_('Failed to retrieve template'))) self.m.ReplayAll() definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Flippy') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.m.VerifyAll()
def parse_stack(self, t, data=None): ctx = utils.dummy_context('test_username', 'aaaa', 'password') stack_name = 'test_stack' tmpl = template.Template(t) stack = parser.Stack(ctx, stack_name, tmpl, adopt_stack_data=data) stack.store() return stack
def test_boolean_type_provider(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'Boolean'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.BOOLEAN)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "False"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def test_system_template_retrieve_by_file(self): # make sure that a TemplateResource defined in the global environment # can be created and the template retrieved using the "file:" # scheme. g_env = resources.global_env() test_templ_name = 'file:///etc/heatr/frodo.yaml' g_env.load({'resource_registry': {'Test::Frodo': test_templ_name}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template), stack_id=str(uuid.uuid4())) minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': {}, 'Resources': {}}) self.m.StubOutWithMock(urlfetch, "get") urlfetch.get(test_templ_name, allowed_schemes=('http', 'https', 'file')).AndReturn(minimal_temp) self.m.ReplayAll() definition = rsrc_defn.ResourceDefinition('test_t_res', 'Test::Frodo') temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate()) self.m.VerifyAll()
def test_properties_extra_required(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Blarg': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Blarg": "wibble"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def test_properties_type_mismatch(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.MAP)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "bar"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) ex = self.assertRaises(exception.StackValidationFailed, temp_res.validate) self.assertEqual("Property Foo type mismatch between facade " "DummyResource (Map) and provider (String)", six.text_type(ex))
def test_attributes_extra(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': {'Value': 'bar'}, 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {} attributes_schema = {"Foo": attributes.Schema("A test attribute")} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource") temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def test_properties_normal(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() properties_schema = {"Foo": properties.Schema(properties.Schema.STRING, required=True)} attributes_schema = {} env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "bar"}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def setUp(self): super(VolumeTypeConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.mock_get_volume_type = mock.Mock() self.ctx.clients.client_plugin( 'cinder').get_volume_type = self.mock_get_volume_type self.constraint = cinder.VolumeTypeConstraint()
def setUp(self): super(TestMistralWorkflow, self).setUp() resources.initialise() utils.setup_dummy_db() self.ctx = utils.dummy_context() tmpl = template_format.parse(workflow_template) self.stack = utils.parse_stack(tmpl, stack_name='test_stack') resource_defns = self.stack.t.resource_definitions(self.stack) self.rsrc_defn = resource_defns['workflow'] self.mistral = mock.Mock() self.patchobject(workflow.Workflow, 'client', return_value=self.mistral) self.patches = [] self.patches.append(mock.patch.object(stack_user.StackUser, '_create_user')) self.patches.append(mock.patch.object(signal_responder.SignalResponder, '_create_keypair')) self.patches.append(mock.patch.object(client, 'mistral_base')) self.patches.append(mock.patch.object(client.MistralClientPlugin, '_create')) for patch in self.patches: patch.start() self.client = client.MistralClientPlugin(self.ctx)
def setUp(self): super(CinderClientPluginTest, self).setUp() self.cinder_client = mock.MagicMock() con = utils.dummy_context() c = con.clients self.cinder_plugin = c.client_plugin('cinder') self.cinder_plugin.client = lambda: self.cinder_client
def setUp(self): super(NovaClientPluginTestCase, self).setUp() self.nova_client = mock.MagicMock() con = utils.dummy_context() c = con.clients self.nova_plugin = c.client_plugin('nova') self.nova_plugin._client = self.nova_client
def setUp(self): super(ServerConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.mock_get_server = mock.Mock() self.ctx.clients.client_plugin( 'nova').get_server = self.mock_get_server self.constraint = nova.ServerConstraint()
def setUp(self): super(VolumeSnapshotConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.mock_get_snapshot = mock.Mock() self.ctx.clients.client_plugin( 'cinder').get_volume_snapshot = self.mock_get_snapshot self.constraint = cinder.VolumeSnapshotConstraint()
def test_validate(self): client = fakes_nova.FakeClient() self.stub_keystoneclient() self.patchobject(nova.NovaClientPlugin, '_create', return_value=client) client.networks = mock.Mock() network = collections.namedtuple("Network", ['id', 'label']) network.id = '7f47ff06-0353-4013-b814-123b70b1b27d' network.label = 'foo' client.networks.get.return_value = network constraint = nova.NetworkConstraint() ctx = utils.dummy_context() self.assertTrue(constraint.validate(network.id, ctx)) client.networks.get.side_effect = nova_exceptions.NotFound('') client.networks.find.return_value = network self.assertTrue(constraint.validate(network.id, ctx)) client.networks.find.side_effect = nova_exceptions.NotFound('') self.assertFalse(constraint.validate(network.id, ctx)) client.networks.find.side_effect = nova_exceptions.NoUniqueMatch() self.assertFalse(constraint.validate(network.id, ctx)) network.id = 'nonuuid' client.networks.find.return_value = network client.networks.find.side_effect = None self.assertTrue(constraint.validate(network.id, ctx))
def _dummy_event(self, event_id): resource = self.stack['generic1'] return Event(utils.dummy_context(), self.stack, 'CREATE', 'COMPLETE', 'state changed', 'z3455xyc-9f88-404d-a85b-5315293e67de', resource.properties, resource.name, resource.type(), uuid='abc123yc-9f88-404d-a85b-531529456xyz', id=event_id)
def test_conv_empty_template_stack_update_delete(self, mock_cr): stack = tools.get_stack('test_stack', utils.dummy_context(), template=tools.string_template_five, convergence=True) stack.store() # create stack stack.converge_stack(template=stack.t, action=stack.CREATE) # update stack with new template template2 = templatem.Template.create_empty_template( version=stack.t.version) curr_stack_db = stack_object.Stack.get_by_id(stack.context, stack.id) curr_stack = parser.Stack.load(curr_stack_db._context, stack=curr_stack_db) # on our previous create_complete, worker would have updated the # rsrc.requires. Mock the same behavior here. self.stack = stack with mock.patch.object( parser.Stack, 'db_active_resources_get', side_effect=self._mock_convg_db_update_requires): curr_stack.thread_group_mgr = tools.DummyThreadGroupManager() curr_stack.converge_stack(template=template2, action=stack.DELETE) self.assertIsNotNone(curr_stack.ext_rsrcs_db) deps = curr_stack.convergence_dependencies self.assertEqual([((3, False), (1, False)), ((3, False), (2, False)), ((4, False), (3, False)), ((5, False), (3, False))], sorted(deps._graph.edges())) stack_db = stack_object.Stack.get_by_id(curr_stack.context, curr_stack.id) self.assertIsNotNone(stack_db.current_traversal) self.assertIsNotNone(stack_db.prev_raw_template_id) self.assertEqual( sorted([[[3, False], [2, False]], [[3, False], [1, False]], [[5, False], [3, False]], [[4, False], [3, False]]]), sorted(stack_db.current_deps['edges'])) # check if sync_points are created for cleanup traversal # [A, B, C, D, E, Stack] for entity_id in [5, 4, 3, 2, 1, stack_db.id]: is_update = False if entity_id == stack_db.id: is_update = True sync_point = sync_point_object.SyncPoint.get_by_key( stack_db._context, entity_id, stack_db.current_traversal, is_update) self.assertIsNotNone(sync_point, 'entity %s' % entity_id) self.assertEqual(stack_db.id, sync_point.stack_id) leaves = set(stack.convergence_dependencies.leaves()) expected_calls = [] for rsrc_id, is_update in sorted(leaves, key=lambda n: n.is_update): expected_calls.append( mock.call.worker_client.WorkerClient.check_resource( stack.context, rsrc_id, stack.current_traversal, {'input_data': {}}, is_update, None, False)) leaves = set(curr_stack.convergence_dependencies.leaves()) for rsrc_id, is_update in sorted(leaves, key=lambda n: n.is_update): expected_calls.append( mock.call.worker_client.WorkerClient.check_resource( curr_stack.context, rsrc_id, curr_stack.current_traversal, {'input_data': {}}, is_update, None, False)) self.assertEqual(expected_calls, mock_cr.mock_calls)
def setUp(self): super(CRONExpressionConstraint, self).setUp() self.ctx = utils.dummy_context() self.constraint = cc.CRONExpressionConstraint()
def setUp(self): super(TimezoneConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.constraint = cc.TimezoneConstraint()
def setUp(self): super(StackDeleteTest, self).setUp() self.ctx = utils.dummy_context() self.man = service.EngineService('a-host', 'a-topic') self.man.create_periodic_tasks()
def get_stack(self, stack_id): ctx = utils.dummy_context(tenant_id='test_tenant') stack = parser.Stack.load(ctx, stack_id) self.stack_id = stack_id return stack
def rollback_stack(self, stack_name): cntxt = utils.dummy_context() db_stack = db_api.stack_get_by_name(cntxt, stack_name) stk = stack.Stack.load(cntxt, stack=db_stack) stk.rollback()
def setUp(self): super(SoftwareDeploymentTest, self).setUp() self.ctx = utils.dummy_context()
def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template_with_nic) kwargs = { 'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861' } tmpl = template.Template(t, env=environment.Environment(kwargs)) self.stack = parser.Stack(utils.dummy_context(), stack_name, tmpl, stack_id=str(uuid.uuid4())) image_id = 'CentOS 5.2' t['Resources']['WebServer']['Properties']['ImageId'] = image_id resource_defns = self.stack.t.resource_definitions(self.stack) nic = net_interfaces.NetworkInterface('%s_nic' % name, resource_defns['nic1'], self.stack) instance = instances.Instance('%s_name' % name, resource_defns['WebServer'], self.stack) metadata = instance.metadata_get() self._mock_get_image_id_success(image_id, 1) self.stub_SubnetConstraint_validate() self.patchobject(nic, 'client', return_value=FakeNeutron()) self.patchobject(neutron.NeutronClientPlugin, '_create', return_value=FakeNeutron()) self.patchobject(nova.NovaClientPlugin, 'client', return_value=self.fc) # need to resolve the template functions server_userdata = instance.client_plugin().build_userdata( metadata, instance.properties['UserData'], 'ec2-user') self.patchobject(nova.NovaClientPlugin, 'build_userdata', return_value=server_userdata) self.patchobject(self.fc.servers, 'create', return_value=return_server) # create network interface scheduler.TaskRunner(nic.create)() self.stack.resources["nic1"] = nic scheduler.TaskRunner(instance.create)() self.fc.servers.create.assert_called_once_with( image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{ 'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251' }], availability_zone=None, block_device_mapping=None) self.m_f_i.assert_called_with(image_id) nova.NovaClientPlugin.build_userdata.assert_called_once_with( metadata, instance.properties['UserData'], 'ec2-user') neutron.NeutronClientPlugin._create.assert_called_once_with() nova.NovaClientPlugin.client.assert_called_with() glance.GlanceClientPlugin.find_image_by_name_or_id.assert_called_with( image_id) return instance
def parse_stack(self, templ_obj): stack_name = 'test_value_stack' stack = parser.Stack(utils.dummy_context(), stack_name, templ_obj) stack.validate() stack.store() return stack
def setUp(self): super(MultipartMimeTest, self).setUp() self.ctx = utils.dummy_context() self.init_config()
def setUp(self): super(ZaqarSubscriptionTest, self).setUp() self.fc = self.m.CreateMockAnything() self.ctx = utils.dummy_context()
def setUp(self): super(ProviderTemplateAdoptTest, self).setUp() self.ctx = utils.dummy_context('test_username', 'aaaa', 'password')
def parse_stack(self, t): stack_name = 'test_stack' tmpl = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, tmpl) stack.store() return stack
def setUp(self): super(DepAttrsTest, self).setUp() self.ctx = utils.dummy_context()
def test_to_parameters(self): """Tests property conversion to parameter values.""" provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'String'}, 'AList': {'Type': 'CommaDelimitedList'}, 'ListEmpty': {'Type': 'CommaDelimitedList'}, 'ANum': {'Type': 'Number'}, 'AMap': {'Type': 'Json'}, }, 'Outputs': { 'Foo': {'Value': 'bar'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): support_status = support.SupportStatus() attributes_schema = {"Foo": attributes.Schema("A test attribute")} properties_schema = { "Foo": {"Type": "String"}, "AList": {"Type": "List"}, "ListEmpty": {"Type": "List"}, "ANum": {"Type": "Number"}, "AMap": {"Type": "Map"} } env = environment.Environment() resource._register_class('DummyResource', DummyResource) env.load({'resource_registry': {'DummyResource': 'test_resource.template'}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template(empty_template, files=files), env=env, stack_id=str(uuid.uuid4())) map_prop_val = { "key1": "val1", "key2": ["lval1", "lval2", "lval3"], "key3": { "key4": 4, "key5": False } } prop_vals = { "Foo": "Bar", "AList": ["one", "two", "three"], "ListEmpty": [], "ANum": 5, "AMap": map_prop_val, } definition = rsrc_defn.ResourceDefinition('test_t_res', 'DummyResource', prop_vals) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) temp_res.validate() converted_params = temp_res.child_params() self.assertTrue(converted_params) for key in DummyResource.properties_schema: self.assertIn(key, converted_params) # verify String conversion self.assertEqual("Bar", converted_params.get("Foo")) # verify List conversion self.assertEqual("one,two,three", converted_params.get("AList")) # verify Number conversion self.assertEqual(5, converted_params.get("ANum")) # verify Map conversion self.assertEqual(map_prop_val, converted_params.get("AMap")) with mock.patch.object(properties.Properties, '__getitem__') as m_get: m_get.side_effect = ValueError('boom') # If the property doesn't exist on INIT, return default value temp_res.action = temp_res.INIT converted_params = temp_res.child_params() for key in DummyResource.properties_schema: self.assertIn(key, converted_params) self.assertEqual({}, converted_params['AMap']) self.assertEqual(0, converted_params['ANum']) # If the property doesn't exist past INIT, then error out temp_res.action = temp_res.CREATE self.assertRaises(ValueError, temp_res.child_params)
def test_wait_metadata(self, mock_identifier, mock_sleep, mock_available, mock_check, mock_handle, *args): """Tests a wait condition metadata update after a signal call.""" mock_available.return_value = (True, None) # Setup Stack temp = template_format.parse(TEST_TEMPLATE_WAIT_CONDITION) template = tmpl.Template(temp) ctx = utils.dummy_context() stack = stk.Stack(ctx, 'test-stack', template, disable_rollback=True) stack.store() self.stub_KeypairConstraint_validate() res_id = identifier.ResourceIdentifier('test_tenant_id', stack.name, stack.id, '', 'WH') mock_identifier.return_value = res_id watch = stack['WC'] inst = stack['S2'] # Setup Sleep Behavior self.run_empty = True def check_empty(sleep_time): self.assertEqual('{}', watch.FnGetAtt('Data')) self.assertIsNone(inst.metadata_get()['test']) def update_metadata(unique_id, data, reason): self.man.resource_signal(ctx, dict(stack.identifier()), 'WH', { 'Data': data, 'Reason': reason, 'Status': 'SUCCESS', 'UniqueId': unique_id }, sync_call=True) def post_success(sleep_time): update_metadata('123', 'foo', 'bar') def side_effect_popper(sleep_time): wh = stack['WH'] if wh.status == wh.IN_PROGRESS: return elif self.run_empty: self.run_empty = False check_empty(sleep_time) else: post_success(sleep_time) mock_sleep.side_effect = side_effect_popper # Test Initial Creation stack.create() self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) self.assertEqual('{"123": "foo"}', watch.FnGetAtt('Data')) self.assertEqual('{"123": "foo"}', inst.metadata_get()['test']) # Test Update update_metadata('456', 'blarg', 'wibble') self.assertEqual({ '123': 'foo', '456': 'blarg' }, jsonutils.loads(watch.FnGetAtt('Data'))) self.assertEqual('{"123": "foo"}', inst.metadata_get()['test']) self.assertEqual({ '123': 'foo', '456': 'blarg' }, jsonutils.loads(inst.metadata_get(refresh=True)['test'])) # Verify outgoing calls self.assertGreater(mock_available.call_count, 0) self.assertEqual(2, mock_handle.call_count) self.assertEqual(2, mock_check.call_count)
def test_get_attribute_autoscaling(self): t = template_format.parse(heat_autoscaling_group_template) tmpl = templatem.Template(t) stack = parser.Stack(utils.dummy_context(), 'test_att', tmpl) rsrc = stack['my_autoscaling_group'] self.assertEqual(0, rsrc.FnGetAtt(rsrc.CURRENT_SIZE))
def _create_test_instance_with_nic(self, return_server, name): stack_name = '%s_s' % name t = template_format.parse(wp_template_with_nic) template = parser.Template(t) kwargs = { 'KeyName': 'test', 'InstanceType': 'm1.large', 'SubnetId': '4156c7a5-e8c4-4aff-a6e1-8f3c7bc83861' } stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment(kwargs), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2' nic = network_interfaces.NetworkInterface('%s_nic' % name, t['Resources']['nic1'], stack) instance = instances.Instance('%s_name' % name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(nic, 'neutron') nic.neutron().MultipleTimes().AndReturn(FakeNeutron()) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(clients.OpenStackClients, 'nova') clients.OpenStackClients.nova().MultipleTimes().AndReturn(self.fc) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData'], 'ec2-user') self.m.StubOutWithMock(nova_utils, 'build_userdata') nova_utils.build_userdata(instance, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=3, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=[{ 'port-id': '64d913c1-bcb1-42d2-8f0a-9593dbcaf251' }], availability_zone=None).AndReturn(return_server) self.m.ReplayAll() # create network interface scheduler.TaskRunner(nic.create)() stack["nic1"] = nic scheduler.TaskRunner(instance.create)() return instance
def setUp(self): super(ManilaShareTypeTest, self).setUp() resources.initialise() utils.setup_dummy_db() self.ctx = utils.dummy_context()
def setUp(self): super(HeatTestCase, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(TemplateTest, self).setUp() self.ctx = utils.dummy_context()
def test_cinder_api_v2_only(self): self.stub_auth(only_services=['volumev2']) ctx = utils.dummy_context() client = clients.Clients(ctx).client('cinder') self.assertEqual(2, client.volume_api_version)
def setUp(self): super(TestRandomString, self).setUp() self.ctx = utils.dummy_context()
def setUp(self): super(ExpirationConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.constraint = cc.ExpirationConstraint()
def test_cinder_api_v1_and_v2(self): self.stub_auth() ctx = utils.dummy_context() client = clients.Clients(ctx).client('cinder') self.assertEqual(2, client.volume_api_version)
def setUp(self): super(FIPDNSNameConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.constraint = cc.RelativeDNSNameConstraint()
def setUp(self): super(DNSDomainConstraintTest, self).setUp() self.ctx = utils.dummy_context() self.constraint = cc.DNSDomainConstraint()
def setUp(self): super(StackServiceWatcherTest, self).setUp() self.ctx = utils.dummy_context(tenant_id='stack_service_test_tenant')
def setUp(self): super(ZaqarMessageQueueTest, self).setUp() self.fc = self.m.CreateMockAnything() self.ctx = utils.dummy_context()