← Back to branch summary

~ubuntu-branches/ubuntu/wily/heat/wily

« back to all changes in this revision

Viewing changes to heat/tests/test_provider_template.py

  • Committer: Package Import Robot
  • Author(s): Corey Bryant, Corey Bryant, James Page
  • Date: 2015-07-07 17:06:19 UTC
  • mfrom: (1.1.26) (45.1.1 vivid-proposed)
  • Revision ID: package-import@ubuntu.com-20150707170619-hra2dbjpfofpou4s
Tags: 1:5.0.0~b1-0ubuntu1
[ Corey Bryant ]
* New upstream milestone for OpenStack Liberty:
  - d/control: Align (build-)depends with upstream.
  - d/p/fix-requirements.patch: Rebased.
  - d/p/sudoers_patch.patch: Rebased.

[ James Page ]
* d/s/options: Ignore any removal of egg-info data during package clean.
* d/control: Drop MySQL and PostgreSQL related BD's, not required for unit
  testing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_provider_template.py
25
25
from heat.common import urlfetch
26
26
from heat.engine import attributes
27
27
from heat.engine import environment
28
 
from heat.engine import parser
29
28
from heat.engine import properties
30
29
from heat.engine import resource
31
30
from heat.engine import resources
32
31
from heat.engine.resources import template_resource
33
32
from heat.engine import rsrc_defn
 
33
from heat.engine import stack as parser
34
34
from heat.engine import support
 
35
from heat.engine import template
35
36
from heat.tests import common
36
37
from heat.tests import generic_resource as generic_rsrc
37
38
from heat.tests import utils
47
48
class ProviderTemplateTest(common.HeatTestCase):
48
49
    def setUp(self):
49
50
        super(ProviderTemplateTest, self).setUp()
50
 
        resource._register_class('OS::ResourceType',
51
 
                                 generic_rsrc.GenericResource)
52
51
        resource._register_class('myCloud::ResourceType',
53
52
                                 MyCloudResource)
54
53
 
57
56
        # default class.
58
57
        env_str = {'resource_registry': {}}
59
58
        env = environment.Environment(env_str)
60
 
        cls = env.get_class('OS::ResourceType', 'fred')
 
59
        cls = env.get_class('GenericResourceType', 'fred')
61
60
        self.assertEqual(generic_rsrc.GenericResource, cls)
62
61
 
63
62
    def test_get_mine_global_map(self):
88
87
        env_str = {'resource_registry': {'resources': {'jerry': {
89
88
            "OS::ResourceType": "myCloud::ResourceType"}}}}
90
89
        env = environment.Environment(env_str)
91
 
        cls = env.get_class('OS::ResourceType', 'fred')
 
90
        cls = env.get_class('GenericResourceType', 'fred')
92
91
        self.assertEqual(generic_rsrc.GenericResource, cls)
93
92
 
94
93
    def test_to_parameters(self):
128
127
        env.load({'resource_registry':
129
128
                  {'DummyResource': 'test_resource.template'}})
130
129
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
131
 
                             parser.Template(empty_template, files=files,
 
130
                             template.Template(empty_template, files=files,
132
131
                             env=env),
133
132
                             stack_id=str(uuid.uuid4()))
134
133
 
209
208
        env.load({'resource_registry':
210
209
                  {'DummyResource': 'test_resource.template'}})
211
210
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
212
 
                             parser.Template(empty_template, files=files,
 
211
                             template.Template(empty_template, files=files,
213
212
                             env=env),
214
213
                             stack_id=str(uuid.uuid4()))
215
214
 
238
237
        env.load({'resource_registry':
239
238
                  {'DummyResource': 'test_resource.template'}})
240
239
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
241
 
                             parser.Template(empty_template, files=files,
 
240
                             template.Template(empty_template, files=files,
242
241
                             env=env),
243
242
                             stack_id=str(uuid.uuid4()))
244
243
 
271
270
        env.load({'resource_registry':
272
271
                  {'DummyResource': 'test_resource.template'}})
273
272
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
274
 
                             parser.Template(empty_template, files=files,
 
273
                             template.Template(empty_template, files=files,
275
274
                             env=env),
276
275
                             stack_id=str(uuid.uuid4()))
277
276
 
303
302
        env.load({'resource_registry':
304
303
                  {'DummyResource': 'test_resource.template'}})
305
304
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
306
 
                             parser.Template(empty_template, files=files,
 
305
                             template.Template(empty_template, files=files,
307
306
                             env=env),
308
307
                             stack_id=str(uuid.uuid4()))
309
308
 
333
332
        env.load({'resource_registry':
334
333
                  {'DummyResource': 'test_resource.template'}})
335
334
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
336
 
                             parser.Template(empty_template, files=files,
 
335
                             template.Template(empty_template, files=files,
337
336
                             env=env),
338
337
                             stack_id=str(uuid.uuid4()))
339
338
 
365
364
        env.load({'resource_registry':
366
365
                  {'DummyResource': 'test_resource.template'}})
367
366
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
368
 
                             parser.Template(
 
367
                             template.Template(
369
368
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
370
369
                                 files=files, env=env),
371
370
                             stack_id=str(uuid.uuid4()))
401
400
        env.load({'resource_registry':
402
401
                  {'DummyResource': 'test_resource.template'}})
403
402
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
404
 
                             parser.Template(
 
403
                             template.Template(
405
404
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
406
405
                                 files=files, env=env),
407
406
                             stack_id=str(uuid.uuid4()))
433
432
        env.load({'resource_registry':
434
433
                  {'DummyResource': 'test_resource.template'}})
435
434
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
436
 
                             parser.Template(
 
435
                             template.Template(
437
436
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
438
437
                                 files=files, env=env),
439
438
                             stack_id=str(uuid.uuid4()))
467
466
                  {'DummyResource': 'test_resource.template',
468
467
                   'resources': {'foo': 'foo.template'}}})
469
468
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
470
 
                             parser.Template(
 
469
                             template.Template(
471
470
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
472
471
                                 files=files, env=env),
473
472
                             stack_id=str(uuid.uuid4()))
502
501
                  {'DummyResource': 'test_resource.template',
503
502
                   'resources': {'foo': {'DummyResource': 'foo.template'}}}})
504
503
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
505
 
                             parser.Template(
 
504
                             template.Template(
506
505
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
507
506
                                 files=files, env=env),
508
507
                             stack_id=str(uuid.uuid4()))
521
520
        env_str = {'resource_registry': {'resources': {'fred': {
522
521
            "OS::ResourceType": "some_magic.yaml"}}}}
523
522
        env = environment.Environment(env_str)
524
 
        ex = self.assertRaises(exception.NotFound, env.get_class,
 
523
        ex = self.assertRaises(exception.TemplateNotFound, env.get_class,
525
524
                               'OS::ResourceType', 'fred')
526
525
        self.assertIn('Could not fetch remote template "some_magic.yaml"',
527
526
                      six.text_type(ex))
546
545
        env.load({'resource_registry':
547
546
                  {'DummyResource': 'test_resource.template'}})
548
547
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
549
 
                             parser.Template(
 
548
                             template.Template(
550
549
                                 {'HeatTemplateFormatVersion': '2012-12-12'},
551
550
                                 files=files, env=env),
552
551
                             stack_id=str(uuid.uuid4()))
608
607
        self.m.ReplayAll()
609
608
 
610
609
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
611
 
                             parser.Template(empty_template),
 
610
                             template.Template(empty_template),
612
611
                             stack_id=str(uuid.uuid4()))
613
612
 
614
613
        properties = {
659
658
        g_env.load({'resource_registry':
660
659
                   {'Test::Frodo': test_templ_name}})
661
660
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
662
 
                             parser.Template(empty_template),
 
661
                             template.Template(empty_template),
663
662
                             stack_id=str(uuid.uuid4()))
664
663
 
665
664
        minimal_temp = json.dumps({'HeatTemplateFormatVersion': '2012-12-12',
687
686
        env.load({'resource_registry':
688
687
                  {'Test::Flippy': test_templ_name}})
689
688
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
690
 
                             parser.Template(empty_template, env=env),
 
689
                             template.Template(empty_template, env=env),
691
690
                             stack_id=str(uuid.uuid4()))
692
691
 
693
692
        definition = rsrc_defn.ResourceDefinition('test_t_res',
709
708
        g_env.load({'resource_registry':
710
709
                   {'Test::Frodo': test_templ_name}})
711
710
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
712
 
                             parser.Template(empty_template),
 
711
                             template.Template(empty_template),
713
712
                             stack_id=str(uuid.uuid4()))
714
713
 
715
714
        self.m.StubOutWithMock(urlfetch, "get")
739
738
        env.load({'resource_registry':
740
739
                  {'Test::Flippy': test_templ_name}})
741
740
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
742
 
                             parser.Template(empty_template, env=env),
 
741
                             template.Template(empty_template, env=env),
743
742
                             stack_id=str(uuid.uuid4()))
744
743
 
745
744
        self.m.StubOutWithMock(urlfetch, "get")
768
767
        env.load({'resource_registry':
769
768
                  {'Test::Flippy': test_templ_name}})
770
769
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
771
 
                             parser.Template(empty_template, env=env),
 
770
                             template.Template(empty_template, env=env),
772
771
                             stack_id=str(uuid.uuid4()))
773
772
 
774
773
        self.m.ReplayAll()
791
790
        env.load({'resource_registry':
792
791
                  {'Test::Tmpl': test_templ_name}})
793
792
        stack = parser.Stack(utils.dummy_context(), 'test_stack',
794
 
                             parser.Template(empty_template, env=env),
 
793
                             template.Template(empty_template, env=env),
795
794
                             stack_id=str(uuid.uuid4()))
796
795
 
797
796
        self.m.StubOutWithMock(urlfetch, "get")
812
811
        self.m.VerifyAll()
813
812
 
814
813
 
 
814
class TemplateDataTest(common.HeatTestCase):
 
815
 
 
816
    def setUp(self):
 
817
        super(TemplateDataTest, self).setUp()
 
818
        files = {}
 
819
        self.ctx = utils.dummy_context()
 
820
 
 
821
        class DummyResource(object):
 
822
            support_status = support.SupportStatus()
 
823
            properties_schema = {"Foo":
 
824
                                 properties.Schema(properties.Schema.STRING,
 
825
                                                   required=True)}
 
826
            attributes_schema = {}
 
827
 
 
828
        env = environment.Environment()
 
829
        resource._register_class('DummyResource', DummyResource)
 
830
        env.load({'resource_registry':
 
831
                  {'DummyResource': 'test_resource.template'}})
 
832
 
 
833
        self.stack = parser.Stack(self.ctx, 'test_stack',
 
834
                                  template.Template(empty_template,
 
835
                                                    files=files,
 
836
                                                    env=env),
 
837
                                  stack_id=str(uuid.uuid4()))
 
838
 
 
839
        self.defn = rsrc_defn.ResourceDefinition('test_t_res',
 
840
                                                 "DummyResource",
 
841
                                                 {"Foo": "bar"})
 
842
        self.res = template_resource.TemplateResource('test_t_res',
 
843
                                                      self.defn, self.stack)
 
844
 
 
845
    def test_template_data_in_update_without_template_file(self):
 
846
        self.res.action = self.res.UPDATE
 
847
        self.res.nested = mock.MagicMock()
 
848
        self.res.get_template_file = mock.Mock(
 
849
            side_effect=exception.TemplateNotFound(
 
850
                message='test_resource.template'))
 
851
        self.assertRaises(exception.TemplateNotFound, self.res.template_data)
 
852
 
 
853
    def test_template_data_in_create_without_template_file(self):
 
854
        self.res.action = self.res.CREATE
 
855
        self.res.nested = mock.MagicMock()
 
856
        self.res.get_template_file = mock.Mock(
 
857
            side_effect=exception.TemplateNotFound(
 
858
                message='test_resource.template'))
 
859
        self.assertEqual(self.res.template_data(), '{}')
 
860
 
 
861
 
815
862
class TemplateResourceCrudTest(common.HeatTestCase):
816
863
    provider = {
817
864
        'HeatTemplateFormatVersion': '2012-12-12',
837
884
        resource._register_class('DummyResource', DummyResource)
838
885
        env.load({'resource_registry':
839
886
                  {'DummyResource': 'test_resource.template'}})
840
 
        stack = parser.Stack(self.ctx, 'test_stack',
841
 
                             parser.Template(empty_template, files=files,
842
 
                                             env=env),
843
 
                             stack_id=str(uuid.uuid4()))
 
887
        self.stack = parser.Stack(self.ctx, 'test_stack',
 
888
                                  template.Template(empty_template,
 
889
                                                    files=files,
 
890
                                                    env=env),
 
891
                                  stack_id=str(uuid.uuid4()))
844
892
 
845
893
        self.defn = rsrc_defn.ResourceDefinition('test_t_res',
846
894
                                                 "DummyResource",
847
895
                                                 {"Foo": "bar"})
848
896
        self.res = template_resource.TemplateResource('test_t_res',
849
 
                                                      self.defn, stack)
 
897
                                                      self.defn, self.stack)
850
898
        self.assertIsNone(self.res.validate())
851
899
 
852
900
    def test_handle_create(self):