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_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_attributes_not_parsable(self): provider = {"HeatTemplateFormatVersion": "2012-12-12", "Outputs": {"Foo": {"Value": "bar"}}} files = {"test_resource.template": json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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", template.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()) nested = mock.Mock() nested.outputs = {"Foo": {"Value": "not-this", "error_msg": "it is all bad"}} nested.output.return_value = None temp_res._nested = nested self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, "Foo")
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): properties_schema = {} attributes_schema = {"Foo": "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({}, files=files), env=env, stack_id=str(uuid.uuid4())) json_snippet = { "Type": "DummyResource", } temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertIsNone(temp_res.validate())
def test_resource_info_special(self): provider = {"HeatTemplateFormatVersion": "2012-12-12", "Parameters": {"Foo": {"Type": "Boolean"}}} files = {"test_resource.template": json.dumps(provider), "foo.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", "resources": {"foo": {"DummyResource": "foo.template"}}, } } ) stack = parser.Stack( utils.dummy_context(), "test_stack", template.Template({"HeatTemplateFormatVersion": "2012-12-12"}, files=files, env=env), stack_id=str(uuid.uuid4()), ) definition = rsrc_defn.ResourceDefinition("foo", "DummyResource", {"Foo": "False"}) temp_res = template_resource.TemplateResource("foo", definition, stack) self.assertEqual("foo.template", temp_res.template_name)
def setUp(self): super(WebHookTest, self).setUp() for res_name, res_class in auto_scale.resource_mapping().items(): resource._register_class(res_name, res_class) self.fake_auto_scale = FakeAutoScale() self.patch(clients.OpenStackClients, 'auto_scale', lambda resource: self.fake_auto_scale)
def test_properties_extra_required(self): provider = { 'Parameters': { 'Blarg': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Blarg": "wibble", }, } 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({}, files=files), env=env, stack_id=str(uuid.uuid4())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
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 setUp(self): super(TemplateResourceCrudTest, self).setUp() files = {'test_resource.template': json.dumps(self.provider)} self.ctx = utils.dummy_context() 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(self.ctx, 'test_stack', parser.Template(empty_template, files=files, env=env), stack_id=str(uuid.uuid4())) self.defn = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": "bar"}) self.res = template_resource.TemplateResource('test_t_res', self.defn, stack) self.assertIsNone(self.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(generic_rsrc.GenericResource): 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", template.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 setUp(self): super(StackTest, self).setUp() self.tmpl = template.Template(copy.deepcopy(empty_template)) self.ctx = utils.dummy_context() resource._register_class('GenericResourceType', generic_rsrc.GenericResource)
def test_nested_stack_create_equals_resource_limit(self): cfg.CONF.set_override('max_resources_per_stack', 2) resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() t = template_format.parse(self.test_template) stack = self.parse_stack(t) stack.create() self.assertEquals(stack.state, (stack.CREATE, stack.COMPLETE)) self.assertIn('NestedResource', stack['the_nested'].nested()) self.m.VerifyAll()
def test_properties_normal(self): provider = { 'Parameters': { 'Foo': {'Type': 'String'}, 'Blarg': {'Type': 'String', 'Default': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.STRING, required=True)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } 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({}, files=files), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertEqual(None, temp_res.validate())
def test_properties_type_match(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Length': {'Type': 'Number'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = {"Length": properties.Schema(properties.Schema.INTEGER)} 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', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Length": 10}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate())
def setUp(self): super(ProviderTemplateTest, self).setUp() utils.setup_dummy_db() resource._register_class('OS::ResourceType', generic_rsrc.GenericResource) resource._register_class('myCloud::ResourceType', MyCloudResource)
def test_properties_type_mismatch(self): provider = { 'Parameters': { 'Foo': {'Type': 'String'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {"Foo": properties.Schema(properties.MAP)} attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } 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({}, files=files), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def setUp(self): super(KeystoneRoleAssignmentMixinTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider explicitly. resource._register_class(RESOURCE_TYPE, DummyRoleAssignment) self.stack = stack.Stack( self.ctx, 'test_stack_keystone', template.Template(keystone_role_assignment_template) ) self.test_role_assignment = self.stack['test_role_assignment'] # Mock client self.keystoneclient = mock.MagicMock() self.test_role_assignment.client = mock.MagicMock() self.test_role_assignment.client.return_value = 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_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
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 test_resource_info_general(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': {'Type': 'Boolean'}, }, } files = {'test_resource.template': json.dumps(provider), 'foo.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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', 'resources': {'foo': 'foo.template'}}}) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.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.assertEqual('test_resource.template', temp_res.template_name)
def test_attributes_missing(self): provider = { 'Outputs': { 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(object): properties_schema = {} attributes_schema = {"Foo": "A test attribute"} json_snippet = { "Type": "DummyResource", } 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({}, files=files), env=env, stack_id=uuidutils.generate_uuid()) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertRaises(exception.StackValidationFailed, temp_res.validate)
def setUp(self): super(MonascaAlarmDefinitionTest, self).setUp() self.ctx = utils.dummy_context() # As monascaclient is not part of requirements.txt, RESOURCE_TYPE is # not registered by default. For testing, its registered here resource._register_class(RESOURCE_TYPE, MonascaAlarmDefinition) self.stack = stack.Stack( self.ctx, 'test_stack', template.Template(sample_template) ) self.test_resource = self.stack['test_resource'] # Mock client plugin self.test_client_plugin = mock.MagicMock() self.test_resource.client_plugin = mock.MagicMock( return_value=self.test_client_plugin) self.test_client_plugin.get_notification.return_value = ( 'sample_notification' ) # Mock client self.test_client = mock.MagicMock() self.test_resource.client = mock.MagicMock( return_value=self.test_client)
def test_instance_group_custom_resource(self): """ If AWS::EC2::Instance is overridden, InstanceGroup will automatically use that overridden resource type. """ # resources may need to be initialised if this is the first test run. resources.initialise() class MyInstance(instance.Instance): """A customized Instance resource.""" original_instance = resource.get_class("AWS::EC2::Instance") resource._register_class("AWS::EC2::Instance", MyInstance) self.addCleanup(resource._register_class, "AWS::EC2::Instance", original_instance) t = template_format.parse(ig_template) stack = utils.parse_stack(t) self._stub_create(1, instance_class=MyInstance) self.m.ReplayAll() conf = self.create_resource(t, stack, 'JobServerConfig') rsrc = self.create_resource(t, stack, 'JobServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) rsrc.delete() self.m.VerifyAll()
def setUp(self): super(ValidateGetAttTest, self).setUp() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) env = environment.Environment() env.load({u'resource_registry': {u'OS::Test::GenericResource': u'GenericResourceType'}}) class FakeResource(generic_rsrc.GenericResource): def FnGetAtt(self, name): pass resource._register_class('OverwrittenFnGetAttType', FakeResource) env.load({u'resource_registry': {u'OS::Test::FakeResource': u'OverwrittenFnGetAttType'}}) self.stack = parser.Stack( utils.dummy_context(), 'test_stack', parser.Template({"HeatTemplateFormatVersion": "2012-12-12"}), env=env, stack_id=str(uuid.uuid4())) res_defn = rsrc_defn.ResourceDefinition('test_rsrc', 'OS::Test::GenericResource') self.rsrc = resource.Resource('test_rsrc', res_defn, self.stack) self.stack.add_resource(self.rsrc)
def setUp(self): super(WebHookTest, self).setUp() for res_name, res_class in auto_scale.resource_mapping().items(): resource._register_class(res_name, res_class) self.fake_auto_scale = FakeAutoScale() self.patchobject(auto_scale.WebHook, 'auto_scale', return_value=self.fake_auto_scale)
def test_attributes_missing_based_on_class(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Blarg': {'Value': 'wibble'}, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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', template.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.assertRaises(exception.StackValidationFailed, temp_res.validate)
def setUp(self): super(KeystoneUserTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider explicitly. resource._register_class(RESOURCE_TYPE, user.KeystoneUser) self.stack = stack.Stack( self.ctx, 'test_stack_keystone', template.Template(keystone_user_template) ) self.test_user = self.stack['test_user'] # Mock client self.keystoneclient = mock.MagicMock() self.test_user.keystone = mock.MagicMock() self.test_user.keystone.return_value = self.keystoneclient self.users = self.keystoneclient.client.users # Mock client plugin def _side_effect(value): return value self.keystone_client_plugin = mock.MagicMock() (self.keystone_client_plugin.get_domain_id. side_effect) = _side_effect (self.keystone_client_plugin.get_group_id. side_effect) = _side_effect (self.keystone_client_plugin.get_project_id. side_effect) = _side_effect self.test_user.client_plugin = mock.MagicMock() (self.test_user.client_plugin. return_value) = self.keystone_client_plugin
def test_nested_stack_adopt_fail(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template').MultipleTimes().\ AndReturn(''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() adopt_data = { "resources": { "the_nested": { "resource_id": "test-res-id", "resources": { } } } } stack = self.adopt_stack(self.test_template, adopt_data) rsrc = stack['the_nested'] self.assertEqual((rsrc.ADOPT, rsrc.FAILED), rsrc.nested().state) nested_name = utils.PhysName(stack.name, 'the_nested') self.assertEqual(nested_name, rsrc.physical_resource_name()) rsrc.delete() self.m.VerifyAll()
def setUp(self): super(KeystoneProjectTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider explicitly. resource._register_class(RESOURCE_TYPE, project.KeystoneProject) self.stack = stack.Stack( self.ctx, 'test_stack_keystone', template.Template(keystone_project_template) ) self.test_project = self.stack['test_project'] # Mock client self.keystoneclient = mock.MagicMock() self.test_project.keystone = mock.MagicMock() self.test_project.keystone.return_value = self.keystoneclient self.projects = self.keystoneclient.client.projects # Mock client plugin def _domain_side_effect(value): return value keystone_client_plugin = mock.MagicMock() keystone_client_plugin.get_domain_id.side_effect = _domain_side_effect self.test_project.client_plugin = mock.MagicMock() self.test_project.client_plugin.return_value = keystone_client_plugin
def setUp(self): super(RackspaceCloudServerTest, self).setUp() self.fc = fakes.FakeClient() setup_dummy_db() # Test environment may not have pyrax client library installed and if # pyrax is not installed resource class would not be registered. # So register resource provider class explicitly for unit testing. resource._register_class("Rackspace::Cloud::Server", cloud_server.CloudServer) f2 = self.m.CreateMockAnything() f2.id = '2' f3 = self.m.CreateMockAnything() f3.id = '3' f4 = self.m.CreateMockAnything() f4.id = '4' f5 = self.m.CreateMockAnything() f5.id = '5' f6 = self.m.CreateMockAnything() f6.id = '6' f7 = self.m.CreateMockAnything() f7.id = '7' f8 = self.m.CreateMockAnything() f8.id = '8' self.flavors = [f2, f3, f4, f5, f6, f7, f8]
def setUp(self): super(CloudServersTest, self).setUp() cfg.CONF.set_override('region_name_for_services', 'RegionOne') self.ctx = utils.dummy_context() self.fc = fakes.FakeClient() mock_nova_create = mock.Mock() self.ctx.clients.client_plugin('nova')._create = mock_nova_create mock_nova_create.return_value = self.fc # Test environment may not have pyrax client library installed and if # pyrax is not installed resource class would not be registered. # So register resource provider class explicitly for unit testing. resource._register_class("OS::Nova::Server", cloud_server.CloudServer)
def setUp(self): super(ScalingGroupTest, self).setUp() for res_name, res_class in auto_scale.resource_mapping().items(): resource._register_class(res_name, res_class) self.fake_auto_scale = FakeAutoScale() self.patchobject(auto_scale.Group, 'auto_scale', return_value=self.fake_auto_scale) # mock nova and glance client methods to satisfy constraints mock_im = self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id') mock_im.return_value = 'image-ref' mock_fl = self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id') mock_fl.return_value = 'flavor-ref'
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 setUp(self): super(SignalTest, self).setUp() utils.setup_dummy_db() resource._register_class('SignalResourceType', generic_resource.SignalResource) resource._register_class('GenericResourceType', generic_resource.GenericResource) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://127.0.0.1:8000/v1/waitcondition') self.stack_id = 'STACKABCD1234' self.fc = fakes.FakeKeystoneClient()
def test_attributes_not_parsable(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': { 'Value': 'bar' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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', template.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) temp_res.resource_id = 'dummy_id' temp_res.nested_identifier = mock.Mock() temp_res.nested_identifier.return_value = {'foo': 'bar'} temp_res._rpc_client = mock.MagicMock() output = { 'outputs': [{ 'output_key': 'Foo', 'output_value': None, 'output_error': 'it is all bad' }] } temp_res._rpc_client.show_stack.return_value = [output] temp_res._rpc_client.list_stack_resources.return_value = [] self.assertIsNone(temp_res.validate()) self.assertRaises(exception.TemplateOutputError, temp_res.FnGetAtt, 'Foo')
def setUp(self): super(TestGroupCrud, self).setUp() resource._register_class('ResourceWithPropsAndAttrs', generic_resource.ResourceWithPropsAndAttrs) cfg.CONF.set_default('heat_waitcondition_server_url', 'http://server.test:8000/v1/waitcondition') self.stub_keystoneclient() self.stub_ImageConstraint_validate() self.stub_FlavorConstraint_validate() self.stub_SnapshotConstraint_validate() t = template_format.parse(inline_templates.as_heat_template) stack = utils.parse_stack(t, params=inline_templates.as_params) self.group = stack['my-group'] self.assertIsNone(self.group.validate())
def setUp(self): super(TestMagnumBayModel, self).setUp() self.ctx = utils.dummy_context() resource._register_class(RESOURCE_TYPE, baymodel.BayModel) t = template_format.parse(self.magnum_template) self.stack = utils.parse_stack(t) resource_defns = self.stack.t.resource_definitions(self.stack) self.rsrc_defn = resource_defns['test_baymodel'] self.client = mock.Mock() self.patchobject(baymodel.BayModel, 'client', return_value=self.client) self.stub_FlavorConstraint_validate() self.stub_KeypairConstraint_validate() self.stub_ImageConstraint_validate() self.stub_NetworkConstraint_validate()
def setUp(self): self.username = '******' self.m = mox.Mox() self.ctx = context.get_admin_context() self.m.StubOutWithMock(self.ctx, 'username') self.ctx.username = self.username self.ctx.tenant_id = 'test_tenant' generic_rsrc.GenericResource.properties_schema = {} resource._register_class('GenericResourceType', generic_rsrc.GenericResource) self.m.ReplayAll()
def setUp(self): super(KeystoneRoleAssignmentMixinTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider explicitly. resource._register_class(RESOURCE_TYPE, DummyRoleAssignment) self.stack = stack.Stack( self.ctx, 'test_stack_keystone', template.Template(keystone_role_assignment_template)) self.test_role_assignment = self.stack['test_role_assignment'] # Mock client self.keystoneclient = mock.MagicMock() self.test_role_assignment.client = mock.MagicMock() self.test_role_assignment.client.return_value = 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_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.parse_assgmnts = self.test_role_assignment.parse_list_assignments 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(StackResourceAttrTest, self).setUp() resource._register_class('some_magic_type', MyStackResource) ws_resname = "provider_resource" t = templatem.Template( {'HeatTemplateFormatVersion': '2012-12-12', 'Resources': {ws_resname: ws_res_snippet}}) self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack', t, stack_id=str(uuid.uuid4()), user_creds_id='uc123', stack_user_project_id='aprojectid') resource_defns = t.resource_definitions(self.parent_stack) self.parent_resource = MyStackResource('test', resource_defns[ws_resname], self.parent_stack)
def setUp(self): super(StackResourceTest, self).setUp() resource._register_class('some_magic_type', MyStackResource) resource._register_class('GenericResource', generic_rsrc.GenericResource) t = parser.Template({'HeatTemplateFormatVersion': '2012-12-12', 'Resources': {"provider_resource": ws_res_snippet}}) self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack', t, stack_id=str(uuid.uuid4())) self.parent_resource = MyStackResource('test', ws_res_snippet, self.parent_stack) self.templ = template_format.parse(param_template) self.simple_template = template_format.parse(simple_template)
def setUp(self): super(FormatTest, self).setUp() utils.setup_dummy_db() template = parser.Template({ 'Resources': { 'generic1': {'Type': 'GenericResourceType'}, 'generic2': { 'Type': 'GenericResourceType', 'DependsOn': 'generic1'} } }) resource._register_class('GenericResourceType', generic_rsrc.GenericResource) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', template, stack_id=str(uuid.uuid4()))
def setUp(self): super(KeystoneRoleTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider explicitly. resource._register_class(RESOURCE_TYPE, KeystoneRole) self.stack = parser.Stack(self.ctx, 'test_stack_keystone', template.Template(keystone_role_template)) self.test_role = self.stack['test_role'] self.keystoneclient = mock.MagicMock() self.test_role.keystone = mock.MagicMock() self.test_role.keystone.return_value = self.keystoneclient self.roles = self.keystoneclient.client.roles
def test_attributes_not_parsable(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Outputs': { 'Foo': { 'Value': 'bar' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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', template.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()) nested = mock.Mock() nested.outputs = { 'Foo': { 'Value': 'not-this', 'error_msg': 'it is all bad' } } nested.output.return_value = None temp_res._nested = nested self.assertRaises(exception.InvalidTemplateAttribute, temp_res.FnGetAtt, 'Foo')
def test_resource_info_special(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': { 'Type': 'Boolean' }, }, } files = { 'test_resource.template': json.dumps(provider), 'foo.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', 'resources': { 'foo': { 'DummyResource': 'foo.template' } } } }) stack = parser.Stack(utils.dummy_context(), 'test_stack', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition('foo', 'DummyResource', {"Foo": "False"}) temp_res = template_resource.TemplateResource('foo', definition, stack) self.assertEqual('foo.template', temp_res.template_name)
def setUp(self): super(RackspaceDnsTest, self).setUp() # Test environment may not have pyrax client library installed and if # pyrax is not installed resource class would not be registered. # So register resource provider class explicitly for unit testing. resource._register_class("Rackspace::Cloud::DNS", cloud_dns.CloudDns) self.create_domain_only_args = { "name": 'dnsheatunittest.com', "emailAddress": '*****@*****.**', "ttl": 3600, "comment": 'Testing Cloud DNS integration with Heat', "records": None } self.update_domain_only_args = { "emailAddress": '*****@*****.**', "ttl": 5555, "comment": 'updated comment' }
def setUp(self): super(TestMagnumClusterTemplate, self).setUp() resource._register_class(RESOURCE_TYPE, cluster_template.ClusterTemplate) self.t = template_format.parse(self.magnum_template) self.stack = utils.parse_stack(self.t) resource_defns = self.stack.t.resource_definitions(self.stack) self.rsrc_defn = resource_defns['test_cluster_template'] self.client = mock.Mock() self.patchobject(cluster_template.ClusterTemplate, 'client', return_value=self.client) self.stub_FlavorConstraint_validate() self.stub_KeypairConstraint_validate() self.stub_ImageConstraint_validate() self.stub_NetworkConstraint_validate() self.stub_SubnetConstraint_validate()
def setUp(self): super(FormatTest, self).setUp() template = parser.Template({ 'HeatTemplateFormatVersion': '2012-12-12', 'Resources': { 'generic1': {'Type': 'GenericResourceType'}, 'generic2': { 'Type': 'GenericResourceType', 'DependsOn': 'generic1'} } }) resource._register_class('GenericResourceType', generic_rsrc.GenericResource) resource._register_class('ResWithComplexPropsAndAttrs', generic_rsrc.ResWithComplexPropsAndAttrs) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', template, stack_id=str(uuid.uuid4()))
def setUp(self): super(NovaFlavorTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider # explicitly. resource._register_class("OS::Nova::Flavor", nova_flavor.NovaFlavor) self.stack = parser.Stack(self.ctx, 'nova_flavor_test_stack', template.Template(flavor_template)) self.my_flavor = self.stack['my_flavor'] nova = mock.MagicMock() self.novaclient = mock.MagicMock() self.my_flavor.nova = nova nova.return_value = self.novaclient self.flavors = self.novaclient.flavors
def setUp(self): super(EventTest, self).setUp() self.username = '******' self.ctx = utils.dummy_context() self.m.ReplayAll() resource._register_class('ResourceWithRequiredProps', generic_rsrc.ResourceWithRequiredProps) self.stack = parser.Stack(self.ctx, 'event_load_test_stack', template.Template(tmpl)) self.stack.store() self.resource = self.stack['EventTestResource'] self.resource._store() self.addCleanup(db_api.stack_delete, self.ctx, self.stack.id)
def setUp(self): super(CinderVolumeTypeTest, self).setUp() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider # explicitly. resource._register_class('OS::Cinder::VolumeType', CinderVolumeType) self.stack = stack.Stack(self.ctx, 'cinder_volume_type_test_stack', template.Template(volume_type_template)) self.my_volume_type = self.stack['my_volume_type'] cinder = mock.MagicMock() self.cinderclient = mock.MagicMock() self.my_volume_type.cinder = cinder cinder.return_value = self.cinderclient self.volume_types = self.cinderclient.volume_types
def setUp(self): super(StackResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('some_magic_type', MyStackResource) resource._register_class('GenericResource', generic_rsrc.GenericResource) t = parser.Template( {template.RESOURCES: { "provider_resource": ws_res_snippet }}) self.parent_stack = parser.Stack(utils.dummy_context(), 'test_stack', t, stack_id=uuidutils.generate_uuid()) self.parent_resource = MyStackResource('test', ws_res_snippet, self.parent_stack) self.templ = template_format.parse(param_template) self.simple_template = template_format.parse(simple_template)
def test_properties_list_with_none(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': { 'Type': "CommaDelimitedList" }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): support_status = support.SupportStatus() properties_schema = { "Foo": properties.Schema(properties.Schema.LIST) } 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', template.Template( {'HeatTemplateFormatVersion': '2012-12-12'}, files=files, env=env), stack_id=str(uuid.uuid4())) definition = rsrc_defn.ResourceDefinition( 'test_t_res', "DummyResource", {"Foo": [None, 'test', None]}) temp_res = template_resource.TemplateResource('test_t_res', definition, stack) self.assertIsNone(temp_res.validate()) definition = rsrc_defn.ResourceDefinition('test_t_res', "DummyResource", {"Foo": [None, None, None]}) 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): properties_schema = { "Foo": properties.Schema(properties.Schema.STRING, required=True) } attributes_schema = {} json_snippet = { "Type": "DummyResource", "Properties": { "Foo": "bar", }, } 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())) temp_res = template_resource.TemplateResource('test_t_res', json_snippet, stack) self.assertIsNone(temp_res.validate())
def setUp(self): super(GlanceImageTest, self).setUp() utils.setup_dummy_db() self.ctx = utils.dummy_context() # For unit testing purpose. Register resource provider # explicitly. resource._register_class("OS::Glance::Image", gi.GlanceImage) tpl = template_format.parse(image_template) self.stack = parser.Stack(self.ctx, 'glance_image_test_stack', parser.Template(tpl)) self.my_image = self.stack['my_image'] glance = mock.MagicMock() self.glanceclient = mock.MagicMock() self.my_image.glance = glance glance.return_value = self.glanceclient self.images = self.glanceclient.images
def setUp(self): super(ResourceTest, self).setUp() utils.setup_dummy_db() resource._register_class('GenericResourceType', generic_rsrc.GenericResource) env = environment.Environment() env.load({ u'resource_registry': { u'OS::Test::GenericResource': u'GenericResourceType' } }) self.stack = parser.Stack(utils.dummy_context(), 'test_stack', parser.Template({}), env=env, stack_id=uuidutils.generate_uuid())
def test_properties_type_mismatch(self): provider = { 'HeatTemplateFormatVersion': '2012-12-12', 'Parameters': { 'Foo': { 'Type': 'String' }, }, } files = {'test_resource.template': json.dumps(provider)} class DummyResource(generic_rsrc.GenericResource): 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', template.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_nested_stack_adopt(self): resource._register_class('GenericResource', generic_rsrc.GenericResource) urlfetch.get('https://server.test/the.template' ).MultipleTimes().AndReturn( ''' HeatTemplateFormatVersion: '2012-12-12' Parameters: KeyName: Type: String Resources: NestedResource: Type: GenericResource Outputs: Foo: Value: bar ''') self.m.ReplayAll() adopt_data = { "resources": { "the_nested": { "resource_id": "test-res-id", "resources": { "NestedResource": { "resource_id": "test-nested-res-id" } } } } } stack = self.adopt_stack(self.test_template, adopt_data) self.assertEqual((stack.ADOPT, stack.COMPLETE), stack.state) rsrc = stack['the_nested'] self.assertEqual((rsrc.ADOPT, rsrc.COMPLETE), rsrc.state) nested_name = utils.PhysName(stack.name, 'the_nested') self.assertEqual(nested_name, rsrc.physical_resource_name()) self.assertEqual('test-nested-res-id', rsrc.nested()['NestedResource'].resource_id) rsrc.delete() self.m.VerifyAll()
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', template.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(ReplaceTest, self).setUp() resource._register_class('ResourceWithPropsAndAttrs', generic_resource.ResourceWithPropsAndAttrs) t = template_format.parse(inline_templates.as_template) self.stack = utils.parse_stack(t, params=inline_templates.as_params) lc = self.create_launch_config(t, self.stack) lcid = lc.FnGetRefId() self.defn = rsrc_defn.ResourceDefinition( 'asg', 'OS::Heat::InstanceGroup', { 'Size': 2, 'AvailabilityZones': ['zoneb'], 'LaunchConfigurationName': lcid }) self.group = instgrp.InstanceGroup('asg', self.defn, self.stack) self.group._lb_reload = mock.Mock() self.group.update_with_template = mock.Mock() self.group.check_update_complete = mock.Mock() self.group._nested = self.get_fake_nested_stack()