← Back to branch summary

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

« back to all changes in this revision

Viewing changes to heat/tests/db/test_sqlalchemy_api.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/db/test_sqlalchemy_api.py
17
17
 
18
18
import mock
19
19
import mox
 
20
from oslo_config import cfg
20
21
from oslo_utils import timeutils
21
22
import six
22
23
 
24
25
from heat.common import exception
25
26
from heat.common import template_format
26
27
from heat.db.sqlalchemy import api as db_api
 
28
from heat.db.sqlalchemy import models
27
29
from heat.engine.clients.os import glance
28
30
from heat.engine.clients.os import nova
29
31
from heat.engine import environment
30
 
from heat.engine import parser
31
32
from heat.engine import resource as rsrc
32
33
from heat.engine.resources.aws.ec2 import instance as instances
33
34
from heat.engine import scheduler
 
35
from heat.engine import stack as parser
 
36
from heat.engine import template as tmpl
34
37
from heat.tests import common
35
38
from heat.tests.nova import fakes as fakes_nova
36
39
from heat.tests import utils
100
103
    def _setup_test_stack(self, stack_name, stack_id=None, owner_id=None,
101
104
                          stack_user_project_id=None, backup=False):
102
105
        t = template_format.parse(wp_template)
103
 
        template = parser.Template(
 
106
        template = tmpl.Template(
104
107
            t, env=environment.Environment({'KeyName': 'test'}))
105
108
        stack_id = stack_id or str(uuid.uuid4())
106
109
        stack = parser.Stack(self.ctx, stack_name, template,
131
134
 
132
135
    def _mock_delete(self, mocks):
133
136
        fc = fakes_nova.FakeClient()
134
 
        mocks.StubOutWithMock(instances.Instance, 'nova')
135
 
        instances.Instance.nova().MultipleTimes().AndReturn(fc)
136
 
        mocks.StubOutWithMock(fc.client, 'get_servers_9999')
137
 
        get = fc.client.get_servers_9999
138
 
        get().MultipleTimes().AndRaise(fakes_nova.fake_exception())
 
137
        mocks.StubOutWithMock(instances.Instance, 'client')
 
138
        instances.Instance.client().MultipleTimes().AndReturn(fc)
 
139
        self.patchobject(fc.servers, 'delete',
 
140
                         side_effect=fakes_nova.fake_exception())
139
141
 
140
142
    @mock.patch.object(db_api, '_paginate_query')
141
143
    def test_filter_and_page_query_paginates_query(self, mock_paginate_query):
282
284
 
283
285
    def test_encryption(self):
284
286
        stack_name = 'test_encryption'
285
 
        (tmpl, stack) = self._setup_test_stack(stack_name)
286
 
        resource_defns = tmpl.resource_definitions(stack)
 
287
        (template, stack) = self._setup_test_stack(stack_name)
 
288
        resource_defns = template.resource_definitions(stack)
287
289
        cs = MyResource('cs_encryption',
288
290
                        resource_defns['WebServer'],
289
291
                        stack)
552
554
        db_api.stack_get_all(self.ctx, sort_keys=sort_keys)
553
555
        self.assertEqual(['id'], sort_keys)
554
556
 
 
557
    def test_stack_get_all_hidden_tags(self):
 
558
        cfg.CONF.set_override('hidden_stack_tags', ['hidden'])
 
559
 
 
560
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
561
        stacks[0].tags = ['hidden']
 
562
        stacks[0].store()
 
563
        stacks[1].tags = ['random']
 
564
        stacks[1].store()
 
565
 
 
566
        st_db = db_api.stack_get_all(self.ctx, show_hidden=True)
 
567
        self.assertEqual(3, len(st_db))
 
568
 
 
569
        st_db_visible = db_api.stack_get_all(self.ctx, show_hidden=False)
 
570
        self.assertEqual(2, len(st_db_visible))
 
571
 
 
572
        # Make sure the hidden stack isn't in the stacks returned by
 
573
        # stack_get_all_visible()
 
574
        for stack in st_db_visible:
 
575
            self.assertNotEqual(stacks[0].id, stack.id)
 
576
 
 
577
    def test_stack_get_all_by_tags(self):
 
578
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
579
        stacks[0].tags = ['tag1']
 
580
        stacks[0].store()
 
581
        stacks[1].tags = ['tag1', 'tag2']
 
582
        stacks[1].store()
 
583
        stacks[2].tags = ['tag1', 'tag2', 'tag3']
 
584
        stacks[2].store()
 
585
 
 
586
        st_db = db_api.stack_get_all(self.ctx, tags=['tag2'])
 
587
        self.assertEqual(2, len(st_db))
 
588
 
 
589
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1', 'tag2'])
 
590
        self.assertEqual(2, len(st_db))
 
591
 
 
592
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1', 'tag2', 'tag3'])
 
593
        self.assertEqual(1, len(st_db))
 
594
 
 
595
    def test_stack_get_all_by_tags_any(self):
 
596
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
597
        stacks[0].tags = ['tag2']
 
598
        stacks[0].store()
 
599
        stacks[1].tags = ['tag1', 'tag2']
 
600
        stacks[1].store()
 
601
        stacks[2].tags = ['tag1', 'tag3']
 
602
        stacks[2].store()
 
603
 
 
604
        st_db = db_api.stack_get_all(self.ctx, tags_any=['tag1'])
 
605
        self.assertEqual(2, len(st_db))
 
606
 
 
607
        st_db = db_api.stack_get_all(self.ctx, tags_any=['tag1', 'tag2',
 
608
                                                         'tag3'])
 
609
        self.assertEqual(3, len(st_db))
 
610
 
 
611
    def test_stack_get_all_by_not_tags(self):
 
612
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
613
        stacks[0].tags = ['tag1']
 
614
        stacks[0].store()
 
615
        stacks[1].tags = ['tag1', 'tag2']
 
616
        stacks[1].store()
 
617
        stacks[2].tags = ['tag1', 'tag2', 'tag3']
 
618
        stacks[2].store()
 
619
 
 
620
        st_db = db_api.stack_get_all(self.ctx, not_tags=['tag2'])
 
621
        self.assertEqual(1, len(st_db))
 
622
 
 
623
        st_db = db_api.stack_get_all(self.ctx, not_tags=['tag1', 'tag2'])
 
624
        self.assertEqual(1, len(st_db))
 
625
 
 
626
        st_db = db_api.stack_get_all(self.ctx, not_tags=['tag1', 'tag2',
 
627
                                                         'tag3'])
 
628
        self.assertEqual(2, len(st_db))
 
629
 
 
630
    def test_stack_get_all_by_not_tags_any(self):
 
631
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
632
        stacks[0].tags = ['tag2']
 
633
        stacks[0].store()
 
634
        stacks[1].tags = ['tag1', 'tag2']
 
635
        stacks[1].store()
 
636
        stacks[2].tags = ['tag1', 'tag3']
 
637
        stacks[2].store()
 
638
 
 
639
        st_db = db_api.stack_get_all(self.ctx, not_tags_any=['tag1'])
 
640
        self.assertEqual(1, len(st_db))
 
641
 
 
642
        st_db = db_api.stack_get_all(self.ctx, not_tags_any=['tag1', 'tag2',
 
643
                                                             'tag3'])
 
644
        self.assertEqual(0, len(st_db))
 
645
 
 
646
    def test_stack_get_all_by_tag_with_pagination(self):
 
647
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
648
        stacks[0].tags = ['tag1']
 
649
        stacks[0].store()
 
650
        stacks[1].tags = ['tag2']
 
651
        stacks[1].store()
 
652
        stacks[2].tags = ['tag1']
 
653
        stacks[2].store()
 
654
 
 
655
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1'])
 
656
        self.assertEqual(2, len(st_db))
 
657
 
 
658
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1'], limit=1)
 
659
        self.assertEqual(1, len(st_db))
 
660
        self.assertEqual(stacks[2].id, st_db[0].id)
 
661
 
 
662
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1'], limit=1,
 
663
                                     marker=stacks[2].id)
 
664
        self.assertEqual(1, len(st_db))
 
665
        self.assertEqual(stacks[0].id, st_db[0].id)
 
666
 
 
667
    def test_stack_get_all_by_tag_with_show_hidden(self):
 
668
        cfg.CONF.set_override('hidden_stack_tags', ['hidden'])
 
669
 
 
670
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
671
        stacks[0].tags = ['tag1']
 
672
        stacks[0].store()
 
673
        stacks[1].tags = ['hidden', 'tag1']
 
674
        stacks[1].store()
 
675
 
 
676
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1'],
 
677
                                     show_hidden=True)
 
678
        self.assertEqual(2, len(st_db))
 
679
 
 
680
        st_db = db_api.stack_get_all(self.ctx, tags=['tag1'],
 
681
                                     show_hidden=False)
 
682
        self.assertEqual(1, len(st_db))
 
683
 
555
684
    def test_stack_count_all(self):
556
685
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
557
686
 
572
701
        st_db = db_api.stack_count_all(self.ctx, show_deleted=True)
573
702
        self.assertEqual(3, st_db)
574
703
 
 
704
    def test_count_all_hidden_tags(self):
 
705
        cfg.CONF.set_override('hidden_stack_tags', ['hidden'])
 
706
 
 
707
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
708
        stacks[0].tags = ['hidden']
 
709
        stacks[0].store()
 
710
        stacks[1].tags = ['random']
 
711
        stacks[1].store()
 
712
 
 
713
        st_db = db_api.stack_count_all(self.ctx, show_hidden=True)
 
714
        self.assertEqual(3, st_db)
 
715
 
 
716
        st_db_visible = db_api.stack_count_all(self.ctx, show_hidden=False)
 
717
        self.assertEqual(2, st_db_visible)
 
718
 
 
719
    def test_count_all_by_tags(self):
 
720
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
721
        stacks[0].tags = ['tag1']
 
722
        stacks[0].store()
 
723
        stacks[1].tags = ['tag2']
 
724
        stacks[1].store()
 
725
        stacks[2].tags = ['tag2']
 
726
        stacks[2].store()
 
727
 
 
728
        st_db = db_api.stack_count_all(self.ctx, tags=['tag1'])
 
729
        self.assertEqual(1, st_db)
 
730
 
 
731
        st_db = db_api.stack_count_all(self.ctx, tags=['tag2'])
 
732
        self.assertEqual(2, st_db)
 
733
 
 
734
    def test_count_all_by_tag_with_show_hidden(self):
 
735
        cfg.CONF.set_override('hidden_stack_tags', ['hidden'])
 
736
 
 
737
        stacks = [self._setup_test_stack('stack', x)[1] for x in UUIDs]
 
738
        stacks[0].tags = ['tag1']
 
739
        stacks[0].store()
 
740
        stacks[1].tags = ['hidden', 'tag1']
 
741
        stacks[1].store()
 
742
 
 
743
        st_db = db_api.stack_count_all(self.ctx, tags=['tag1'],
 
744
                                       show_hidden=True)
 
745
        self.assertEqual(2, st_db)
 
746
 
 
747
        st_db = db_api.stack_count_all(self.ctx, tags=['tag1'],
 
748
                                       show_hidden=False)
 
749
        self.assertEqual(1, st_db)
 
750
 
575
751
    def test_stack_count_all_with_filters(self):
576
752
        self._setup_test_stack('foo', UUID1)
577
753
        self._setup_test_stack('bar', UUID2)
605
781
        self.m.UnsetStubs()
606
782
 
607
783
        events = db_api.event_get_all_by_stack(self.ctx, UUID1)
608
 
        self.assertEqual(2, len(events))
 
784
        self.assertEqual(4, len(events))
609
785
 
610
786
        # test filter by resource_status
611
787
        filters = {'resource_status': 'COMPLETE'}
612
788
        events = db_api.event_get_all_by_stack(self.ctx, UUID1,
613
789
                                               filters=filters)
614
 
        self.assertEqual(1, len(events))
 
790
        self.assertEqual(2, len(events))
615
791
        self.assertEqual('COMPLETE', events[0].resource_status)
 
792
        self.assertEqual('COMPLETE', events[1].resource_status)
616
793
        # test filter by resource_action
617
794
        filters = {'resource_action': 'CREATE'}
618
795
        events = db_api.event_get_all_by_stack(self.ctx, UUID1,
619
796
                                               filters=filters)
620
 
        self.assertEqual(2, len(events))
 
797
        self.assertEqual(4, len(events))
621
798
        self.assertEqual('CREATE', events[0].resource_action)
622
799
        self.assertEqual('CREATE', events[1].resource_action)
 
800
        self.assertEqual('CREATE', events[2].resource_action)
 
801
        self.assertEqual('CREATE', events[3].resource_action)
623
802
        # test filter by resource_type
624
803
        filters = {'resource_type': 'AWS::EC2::Instance'}
625
804
        events = db_api.event_get_all_by_stack(self.ctx, UUID1,
649
828
        filters = {'resource_status': 'COMPLETE'}
650
829
        events = db_api.event_get_all_by_stack(self.ctx, UUID1,
651
830
                                               filters=filters)
652
 
        self.assertEqual(2, len(events))
 
831
        self.assertEqual(4, len(events))
653
832
        self.assertEqual('COMPLETE', events[0].resource_status)
654
833
        self.assertEqual('COMPLETE', events[1].resource_status)
 
834
        self.assertEqual('COMPLETE', events[2].resource_status)
 
835
        self.assertEqual('COMPLETE', events[3].resource_status)
655
836
        # test filter by resource_action
656
837
        filters = {'resource_action': 'DELETE',
657
838
                   'resource_status': 'COMPLETE'}
658
839
        events = db_api.event_get_all_by_stack(self.ctx, UUID1,
659
840
                                               filters=filters)
660
 
        self.assertEqual(1, len(events))
 
841
        self.assertEqual(2, len(events))
661
842
        self.assertEqual('DELETE', events[0].resource_action)
662
843
        self.assertEqual('COMPLETE', events[0].resource_status)
 
844
        self.assertEqual('DELETE', events[1].resource_action)
 
845
        self.assertEqual('COMPLETE', events[1].resource_status)
663
846
        # test limit and marker
664
847
        events_all = db_api.event_get_all_by_stack(self.ctx, UUID1)
665
 
        self.assertEqual(4, len(events_all))
 
848
        self.assertEqual(8, len(events_all))
666
849
 
667
850
        marker = events_all[1].uuid
668
851
        events2_uuid = events_all[2].uuid
689
872
        self.m.UnsetStubs()
690
873
 
691
874
        num_events = db_api.event_count_all_by_stack(self.ctx, UUID1)
692
 
        self.assertEqual(2, num_events)
693
 
 
694
 
        self._mock_delete(self.m)
695
 
        self.m.ReplayAll()
696
 
        stack.delete()
697
 
 
698
 
        num_events = db_api.event_count_all_by_stack(self.ctx, UUID1)
699
875
        self.assertEqual(4, num_events)
700
876
 
 
877
        self._mock_delete(self.m)
 
878
        self.m.ReplayAll()
 
879
        stack.delete()
 
880
 
 
881
        num_events = db_api.event_count_all_by_stack(self.ctx, UUID1)
 
882
        self.assertEqual(8, num_events)
 
883
 
701
884
        self.m.VerifyAll()
702
885
 
703
886
    def test_event_get_all_by_tenant(self):
709
892
        self.m.UnsetStubs()
710
893
 
711
894
        events = db_api.event_get_all_by_tenant(self.ctx)
712
 
        self.assertEqual(6, len(events))
 
895
        self.assertEqual(12, len(events))
713
896
 
714
897
        self._mock_delete(self.m)
715
898
        self.m.ReplayAll()
729
912
        self.m.UnsetStubs()
730
913
 
731
914
        events = db_api.event_get_all(self.ctx)
732
 
        self.assertEqual(6, len(events))
 
915
        self.assertEqual(12, len(events))
733
916
 
734
917
        self._mock_delete(self.m)
735
918
        self.m.ReplayAll()
736
919
        stacks[0].delete()
737
920
 
738
921
        events = db_api.event_get_all(self.ctx)
739
 
        self.assertEqual(4, len(events))
 
922
        self.assertEqual(8, len(events))
740
923
 
741
924
        self.m.VerifyAll()
742
925
 
743
926
    def test_user_creds_password(self):
744
927
        self.ctx.trust_id = None
745
 
        self.ctx.region_name = 'regionOne'
 
928
        self.ctx.region_name = 'RegionOne'
746
929
        db_creds = db_api.user_creds_create(self.ctx)
747
930
        load_creds = db_api.user_creds_get(db_creds.id)
748
931
 
750
933
        self.assertEqual('password', load_creds.get('password'))
751
934
        self.assertEqual('test_tenant', load_creds.get('tenant'))
752
935
        self.assertEqual('test_tenant_id', load_creds.get('tenant_id'))
753
 
        self.assertEqual('regionOne', load_creds.get('region_name'))
 
936
        self.assertEqual('RegionOne', load_creds.get('region_name'))
754
937
        self.assertIsNotNone(load_creds.get('created_at'))
755
938
        self.assertIsNone(load_creds.get('updated_at'))
756
939
        self.assertEqual('http://server.test:5000/v2.0',
1016
1199
        self.assertEqual(values['status'], snapshot.status)
1017
1200
        self.assertIsNotNone(snapshot.created_at)
1018
1201
 
 
1202
    def test_snapshot_get_by_another_stack(self):
 
1203
        template = create_raw_template(self.ctx)
 
1204
        user_creds = create_user_creds(self.ctx)
 
1205
        stack = create_stack(self.ctx, template, user_creds)
 
1206
        stack1 = create_stack(self.ctx, template, user_creds)
 
1207
        values = {'tenant': self.ctx.tenant_id, 'status': 'IN_PROGRESS',
 
1208
                  'stack_id': stack.id}
 
1209
        snapshot = db_api.snapshot_create(self.ctx, values)
 
1210
        self.assertIsNotNone(snapshot)
 
1211
        snapshot_id = snapshot.id
 
1212
        self.assertRaises(exception.SnapshotNotFound,
 
1213
                          db_api.snapshot_get_by_stack,
 
1214
                          self.ctx, snapshot_id, stack1)
 
1215
 
1019
1216
    def test_snapshot_get_not_found_invalid_tenant(self):
1020
1217
        template = create_raw_template(self.ctx)
1021
1218
        user_creds = create_user_creds(self.ctx)
1274
1471
        self.assertEqual(new_t, updated_tp.template)
1275
1472
        self.assertEqual(new_files, updated_tp.files)
1276
1473
 
 
1474
    def test_raw_template_delete(self):
 
1475
        t = template_format.parse(wp_template)
 
1476
        tp = create_raw_template(self.ctx, template=t)
 
1477
        db_api.raw_template_delete(self.ctx, tp.id)
 
1478
        self.assertRaises(exception.NotFound, db_api.raw_template_get,
 
1479
                          self.ctx, tp.id)
 
1480
 
1277
1481
 
1278
1482
class DBAPIUserCredsTest(common.HeatTestCase):
1279
1483
    def setUp(self):
1324
1528
        self.assertIn(exp_msg, six.text_type(err))
1325
1529
 
1326
1530
 
 
1531
class DBAPIStackTagTest(common.HeatTestCase):
 
1532
    def setUp(self):
 
1533
        super(DBAPIStackTagTest, self).setUp()
 
1534
        self.ctx = utils.dummy_context()
 
1535
        self.template = create_raw_template(self.ctx)
 
1536
        self.user_creds = create_user_creds(self.ctx)
 
1537
        self.stack = create_stack(self.ctx, self.template, self.user_creds)
 
1538
 
 
1539
    def test_stack_tags_set(self):
 
1540
        tags = db_api.stack_tags_set(self.ctx, self.stack.id, ['tag1', 'tag2'])
 
1541
        self.assertEqual(self.stack.id, tags[0].stack_id)
 
1542
        self.assertEqual('tag1', tags[0].tag)
 
1543
 
 
1544
        tags = db_api.stack_tags_set(self.ctx, self.stack.id, [])
 
1545
        self.assertIsNone(tags)
 
1546
 
 
1547
    def test_stack_tags_get(self):
 
1548
        db_api.stack_tags_set(self.ctx, self.stack.id, ['tag1', 'tag2'])
 
1549
        tags = db_api.stack_tags_get(self.ctx, self.stack.id)
 
1550
        self.assertEqual(self.stack.id, tags[0].stack_id)
 
1551
        self.assertEqual('tag1', tags[0].tag)
 
1552
 
 
1553
        tags = db_api.stack_tags_get(self.ctx, UUID1)
 
1554
        self.assertIsNone(tags)
 
1555
 
 
1556
    def test_stack_tags_delete(self):
 
1557
        db_api.stack_tags_set(self.ctx, self.stack.id, ['tag1', 'tag2'])
 
1558
        db_api.stack_tags_delete(self.ctx, self.stack.id)
 
1559
        tags = db_api.stack_tags_get(self.ctx, self.stack.id)
 
1560
        self.assertIsNone(tags)
 
1561
 
 
1562
 
1327
1563
class DBAPIStackTest(common.HeatTestCase):
1328
1564
    def setUp(self):
1329
1565
        super(DBAPIStackTest, self).setUp()
1572
1808
            self.assertIsNone(db_api.stack_get(ctx, stacks[s].id,
1573
1809
                                               show_deleted=True))
1574
1810
 
 
1811
    def test_stack_get_root_id(self):
 
1812
        root = create_stack(self.ctx, self.template, self.user_creds,
 
1813
                            name='root stack')
 
1814
        child_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1815
                               name='child 1 stack', owner_id=root.id)
 
1816
        child_2 = create_stack(self.ctx, self.template, self.user_creds,
 
1817
                               name='child 2 stack', owner_id=child_1.id)
 
1818
        child_3 = create_stack(self.ctx, self.template, self.user_creds,
 
1819
                               name='child 3 stack', owner_id=child_2.id)
 
1820
 
 
1821
        self.assertEqual(root.id, db_api.stack_get_root_id(
 
1822
            self.ctx, child_3.id))
 
1823
        self.assertEqual(root.id, db_api.stack_get_root_id(
 
1824
            self.ctx, child_2.id))
 
1825
        self.assertEqual(root.id, db_api.stack_get_root_id(
 
1826
            self.ctx, root.id))
 
1827
        self.assertEqual(root.id, db_api.stack_get_root_id(
 
1828
            self.ctx, child_1.id))
 
1829
 
 
1830
    def test_stack_count_total_resources(self):
 
1831
 
 
1832
        def add_resources(stack, count):
 
1833
            for i in range(count):
 
1834
                create_resource(
 
1835
                    self.ctx, stack, name='%s-%s' % (stack.name, i))
 
1836
 
 
1837
        root = create_stack(self.ctx, self.template, self.user_creds,
 
1838
                            name='root stack')
 
1839
 
 
1840
        # stack with 3 children
 
1841
        s_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1842
                           name='s_1', owner_id=root.id)
 
1843
        s_1_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1844
                             name='s_1_1', owner_id=s_1.id)
 
1845
        s_1_2 = create_stack(self.ctx, self.template, self.user_creds,
 
1846
                             name='s_1_2', owner_id=s_1.id)
 
1847
        s_1_3 = create_stack(self.ctx, self.template, self.user_creds,
 
1848
                             name='s_1_3', owner_id=s_1.id)
 
1849
 
 
1850
        # stacks 4 ancestors deep
 
1851
        s_2 = create_stack(self.ctx, self.template, self.user_creds,
 
1852
                           name='s_2', owner_id=root.id)
 
1853
        s_2_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1854
                             name='s_2_1', owner_id=s_2.id)
 
1855
        s_2_1_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1856
                               name='s_2_1_1', owner_id=s_2_1.id)
 
1857
        s_2_1_1_1 = create_stack(self.ctx, self.template, self.user_creds,
 
1858
                                 name='s_2_1_1_1', owner_id=s_2_1_1.id)
 
1859
 
 
1860
        s_3 = create_stack(self.ctx, self.template, self.user_creds,
 
1861
                           name='s_3', owner_id=root.id)
 
1862
        s_4 = create_stack(self.ctx, self.template, self.user_creds,
 
1863
                           name='s_4', owner_id=root.id)
 
1864
 
 
1865
        add_resources(root, 3)
 
1866
        add_resources(s_1, 2)
 
1867
        add_resources(s_1_1, 4)
 
1868
        add_resources(s_1_2, 5)
 
1869
        add_resources(s_1_3, 6)
 
1870
 
 
1871
        add_resources(s_2, 1)
 
1872
        add_resources(s_2_1_1_1, 1)
 
1873
        add_resources(s_3, 4)
 
1874
 
 
1875
        self.assertEqual(26, db_api.stack_count_total_resources(
 
1876
            self.ctx, root.id))
 
1877
 
 
1878
        self.assertEqual(17, db_api.stack_count_total_resources(
 
1879
            self.ctx, s_1.id))
 
1880
        self.assertEqual(4, db_api.stack_count_total_resources(
 
1881
            self.ctx, s_1_1.id))
 
1882
        self.assertEqual(5, db_api.stack_count_total_resources(
 
1883
            self.ctx, s_1_2.id))
 
1884
        self.assertEqual(6, db_api.stack_count_total_resources(
 
1885
            self.ctx, s_1_3.id))
 
1886
 
 
1887
        self.assertEqual(2, db_api.stack_count_total_resources(
 
1888
            self.ctx, s_2.id))
 
1889
        self.assertEqual(1, db_api.stack_count_total_resources(
 
1890
            self.ctx, s_2_1.id))
 
1891
        self.assertEqual(1, db_api.stack_count_total_resources(
 
1892
            self.ctx, s_2_1_1.id))
 
1893
        self.assertEqual(1, db_api.stack_count_total_resources(
 
1894
            self.ctx, s_2_1_1_1.id))
 
1895
        self.assertEqual(4, db_api.stack_count_total_resources(
 
1896
            self.ctx, s_3.id))
 
1897
        self.assertEqual(0, db_api.stack_count_total_resources(
 
1898
            self.ctx, s_4.id))
 
1899
        self.assertEqual(0, db_api.stack_count_total_resources(
 
1900
            self.ctx, 'asdf'))
 
1901
        self.assertEqual(0, db_api.stack_count_total_resources(
 
1902
            self.ctx, None))
 
1903
 
1575
1904
 
1576
1905
class DBAPIResourceTest(common.HeatTestCase):
1577
1906
    def setUp(self):
2354
2683
            self.ctx, self.stack.id, self.stack.current_traversal, True
2355
2684
        )
2356
2685
        self.assertEqual(None, ret_sync_point_stack)
 
2686
 
 
2687
 
 
2688
class DBAPICryptParamsPropsTest(common.HeatTestCase):
 
2689
    def setUp(self):
 
2690
        super(DBAPICryptParamsPropsTest, self).setUp()
 
2691
        self.ctx = utils.dummy_context()
 
2692
        t = template_format.parse('''
 
2693
        heat_template_version: 2013-05-23
 
2694
        parameters:
 
2695
            param1:
 
2696
                type: string
 
2697
                description: value1.
 
2698
            param2:
 
2699
                type: string
 
2700
                description: value2.
 
2701
                hidden: true
 
2702
        resources:
 
2703
            a_resource:
 
2704
                type: GenericResourceType
 
2705
        ''')
 
2706
        template = {
 
2707
            'template': t,
 
2708
            'files': {'foo': 'bar'},
 
2709
            'environment': {'parameters': {'param1': 'foo',
 
2710
                                           'param2': 'bar'}}}
 
2711
        self.template = db_api.raw_template_create(self.ctx, template)
 
2712
 
 
2713
    def test_db_encrypt_decrypt(self):
 
2714
        session = db_api.get_session()
 
2715
 
 
2716
        env = session.query(models.RawTemplate).all()[0].environment
 
2717
        self.assertEqual('bar', env['parameters']['param2'])
 
2718
 
 
2719
        db_api.db_encrypt_parameters_and_properties(
 
2720
            self.ctx, cfg.CONF.auth_encryption_key)
 
2721
 
 
2722
        env = session.query(models.RawTemplate).all()[0].environment
 
2723
        self.assertEqual('oslo_decrypt_v1',
 
2724
                         env['parameters']['param2'][0])
 
2725
 
 
2726
        db_api.db_decrypt_parameters_and_properties(
 
2727
            self.ctx, cfg.CONF.auth_encryption_key)
 
2728
 
 
2729
        env = session.query(models.RawTemplate).all()[0].environment
 
2730
        self.assertEqual('bar', env['parameters']['param2'])
 
2731
 
 
2732
        # Use a different encryption key to decrypt
 
2733
        db_api.db_encrypt_parameters_and_properties(
 
2734
            self.ctx, cfg.CONF.auth_encryption_key)
 
2735
        db_api.db_decrypt_parameters_and_properties(
 
2736
            self.ctx, '774c15be099ea74123a9b9592ff12680')
 
2737
 
 
2738
        env = session.query(models.RawTemplate).all()[0].environment
 
2739
        self.assertNotEqual('bar', env['parameters']['param2'])