← Back to branch summary

~ubuntu-branches/ubuntu/trusty/heat/trusty-security

« back to all changes in this revision

Viewing changes to heat/tests/test_api_cfn_v1.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-09-08 21:51:19 UTC
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: package-import@ubuntu.com-20130908215119-7tcek6gn73275x5k
Tags: upstream-2013.2~b3
Import upstream version 2013.2~b3

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_api_cfn_v1.py
17
17
 
18
18
from oslo.config import cfg
19
19
 
 
20
from heat.common import exception as heat_exception
20
21
from heat.common import identifier
21
22
from heat.common import policy
22
23
from heat.openstack.common import rpc
23
 
import heat.openstack.common.rpc.common as rpc_common
24
24
from heat.common.wsgi import Request
25
25
from heat.rpc import api as rpc_api
26
26
from heat.api.aws import exception
27
27
import heat.api.cfn.v1.stacks as stacks
28
28
from heat.tests.common import HeatTestCase
29
 
from heat.tests.utils import dummy_context
 
29
from heat.tests import utils
30
30
 
31
31
policy_path = os.path.dirname(os.path.realpath(__file__)) + "/policy/"
32
32
 
42
42
        qs = "&".join(["=".join([k, str(params[k])]) for k in params])
43
43
        environ = {'REQUEST_METHOD': 'GET', 'QUERY_STRING': qs}
44
44
        req = Request(environ)
45
 
        req.context = dummy_context()
 
45
        req.context = utils.dummy_context()
46
46
        return req
47
47
 
48
48
    # The tests
152
152
                  'method': 'list_stacks',
153
153
                  'args': {},
154
154
                  'version': self.api_version},
155
 
                 None).AndRaise(rpc_common.RemoteError("AttributeError"))
 
155
                 None).AndRaise(AttributeError())
156
156
 
157
157
        self.m.ReplayAll()
158
158
 
174
174
                  'method': 'list_stacks',
175
175
                  'args': {},
176
176
                  'version': self.api_version},
177
 
                 None).AndRaise(rpc_common.RemoteError("Exception"))
 
177
                 None).AndRaise(Exception())
178
178
 
179
179
        self.m.ReplayAll()
180
180
 
372
372
                  'method': 'show_stack',
373
373
                  'args': {'stack_identity': identity},
374
374
                  'version': self.api_version},
375
 
                 None).AndRaise(rpc_common.RemoteError("InvalidTenant"))
 
375
                 None).AndRaise(heat_exception.InvalidTenant())
376
376
 
377
377
        self.m.ReplayAll()
378
378
 
400
400
                  'method': 'show_stack',
401
401
                  'args': {'stack_identity': identity},
402
402
                  'version': self.api_version}, None
403
 
                 ).AndRaise(rpc_common.RemoteError("AttributeError"))
 
403
                 ).AndRaise(AttributeError())
404
404
 
405
405
        self.m.ReplayAll()
406
406
 
422
422
                  'method': 'identify_stack',
423
423
                  'args': {'stack_name': stack_name},
424
424
                  'version': self.api_version}, None
425
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
425
                 ).AndRaise(heat_exception.StackNotFound())
426
426
 
427
427
        self.m.ReplayAll()
428
428
 
743
743
                           'files': {},
744
744
                           'args': engine_args},
745
745
                  'version': self.api_version}, None
746
 
                 ).AndRaise(rpc_common.RemoteError("AttributeError"))
747
 
        rpc.call(dummy_req.context, self.topic,
748
 
                 {'namespace': None,
749
 
                  'method': 'create_stack',
750
 
                  'args': {'stack_name': stack_name,
751
 
                           'template': template,
752
 
                           'params': engine_parms,
753
 
                           'files': {},
754
 
                           'args': engine_args},
755
 
                  'version': self.api_version}, None
756
 
                 ).AndRaise(rpc_common.RemoteError("UnknownUserParameter"))
757
 
        rpc.call(dummy_req.context, self.topic,
758
 
                 {'namespace': None,
759
 
                  'method': 'create_stack',
760
 
                  'args': {'stack_name': stack_name,
761
 
                           'template': template,
762
 
                           'params': engine_parms,
763
 
                           'files': {},
764
 
                           'args': engine_args},
765
 
                  'version': self.api_version}, None
766
 
                 ).AndRaise(rpc_common.RemoteError("UserParameterMissing"))
 
746
                 ).AndRaise(AttributeError())
 
747
        rpc.call(dummy_req.context, self.topic,
 
748
                 {'namespace': None,
 
749
                  'method': 'create_stack',
 
750
                  'args': {'stack_name': stack_name,
 
751
                           'template': template,
 
752
                           'params': engine_parms,
 
753
                           'files': {},
 
754
                           'args': engine_args},
 
755
                  'version': self.api_version}, None
 
756
                 ).AndRaise(heat_exception.UnknownUserParameter())
 
757
        rpc.call(dummy_req.context, self.topic,
 
758
                 {'namespace': None,
 
759
                  'method': 'create_stack',
 
760
                  'args': {'stack_name': stack_name,
 
761
                           'template': template,
 
762
                           'params': engine_parms,
 
763
                           'files': {},
 
764
                           'args': engine_args},
 
765
                  'version': self.api_version}, None
 
766
                 ).AndRaise(heat_exception.UserParameterMissing())
767
767
 
768
768
        self.m.ReplayAll()
769
769
 
811
811
                           'files': {},
812
812
                           'args': engine_args},
813
813
                  'version': self.api_version}, None
814
 
                 ).AndRaise(rpc_common.RemoteError("StackExists"))
 
814
                 ).AndRaise(heat_exception.StackExists())
815
815
 
816
816
        self.m.ReplayAll()
817
817
 
821
821
                         exception.AlreadyExistsError)
822
822
        self.m.VerifyAll()
823
823
 
824
 
    def test_invalid_state_err(self):
825
 
        '''
826
 
        Test that an ActionInProgress exception results in a
827
 
        HeatInvalidStateError.
828
 
 
829
 
        '''
830
 
        # Format a dummy request
831
 
        stack_name = "wordpress"
832
 
        template = {u'Foo': u'bar'}
833
 
        json_template = json.dumps(template)
834
 
        params = {'Action': 'CreateStack', 'StackName': stack_name,
835
 
                  'TemplateBody': '%s' % json_template,
836
 
                  'TimeoutInMinutes': 30,
837
 
                  'Parameters.member.1.ParameterKey': 'InstanceType',
838
 
                  'Parameters.member.1.ParameterValue': 'm1.xlarge'}
839
 
        engine_parms = {u'InstanceType': u'm1.xlarge'}
840
 
        engine_args = {'timeout_mins': u'30'}
841
 
        dummy_req = self._dummy_GET_request(params)
842
 
 
843
 
        # Insert an engine RPC error and ensure we map correctly to the
844
 
        # heat exception type
845
 
        self.m.StubOutWithMock(rpc, 'call')
846
 
 
847
 
        rpc.call(dummy_req.context, self.topic,
848
 
                 {'namespace': None,
849
 
                  'method': 'create_stack',
850
 
                  'args': {'stack_name': stack_name,
851
 
                           'template': template,
852
 
                           'params': engine_parms,
853
 
                           'files': {},
854
 
                           'args': engine_args},
855
 
                  'version': self.api_version}, None
856
 
                 ).AndRaise(rpc_common.RemoteError("ActionInProgress"))
857
 
 
858
 
        self.m.ReplayAll()
859
 
 
860
 
        result = self.controller.create(dummy_req)
861
 
 
862
 
        self.assertEqual(type(result),
863
 
                         exception.HeatInvalidStateError)
864
 
        self.m.VerifyAll()
865
 
 
866
824
    def test_create_err_engine(self):
867
825
        # Format a dummy request
868
826
        stack_name = "wordpress"
889
847
                  'files': {},
890
848
                  'args': engine_args},
891
849
                  'version': self.api_version}, None).AndRaise(
892
 
                      rpc_common.RemoteError(
893
 
                          'StackValidationFailed',
894
 
                          'Something went wrong'))
 
850
                      heat_exception.StackValidationFailed(
 
851
                          message='Something went wrong'))
895
852
 
896
853
        self.m.ReplayAll()
897
854
 
968
925
                  'method': 'identify_stack',
969
926
                  'args': {'stack_name': stack_name},
970
927
                  'version': self.api_version}, None
971
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
928
                 ).AndRaise(heat_exception.StackNotFound())
972
929
 
973
930
        self.m.ReplayAll()
974
931
 
1035
992
                  'method': 'get_template',
1036
993
                  'args': {'stack_identity': identity},
1037
994
                  'version': self.api_version}, None
1038
 
                 ).AndRaise(rpc_common.RemoteError("AttributeError"))
 
995
                 ).AndRaise(AttributeError())
1039
996
 
1040
997
        self.m.ReplayAll()
1041
998
 
1058
1015
                  'method': 'identify_stack',
1059
1016
                  'args': {'stack_name': stack_name},
1060
1017
                  'version': self.api_version}, None
1061
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1018
                 ).AndRaise(heat_exception.StackNotFound())
1062
1019
 
1063
1020
        self.m.ReplayAll()
1064
1021
 
1203
1160
                  'method': 'delete_stack',
1204
1161
                  'args': {'stack_identity': identity},
1205
1162
                  'version': self.api_version}, None
1206
 
                 ).AndRaise(rpc_common.RemoteError("AttributeError"))
 
1163
                 ).AndRaise(AttributeError())
1207
1164
 
1208
1165
        self.m.ReplayAll()
1209
1166
 
1226
1183
                  'method': 'identify_stack',
1227
1184
                  'args': {'stack_name': stack_name},
1228
1185
                  'version': self.api_version}, None
1229
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1186
                 ).AndRaise(heat_exception.StackNotFound())
1230
1187
 
1231
1188
        self.m.ReplayAll()
1232
1189
 
1249
1206
                                            u'stack_name': u'wordpress',
1250
1207
                                            u'stack_id': u'6',
1251
1208
                                            u'path': u''},
1252
 
                        u'logical_resource_id': u'WikiDatabase',
 
1209
                        u'resource_name': u'WikiDatabase',
1253
1210
                        u'resource_status_reason': u'state changed',
1254
1211
                        u'event_identity':
1255
1212
                        {u'tenant': u't',
1315
1272
                  'method': 'list_events',
1316
1273
                  'args': {'stack_identity': identity},
1317
1274
                  'version': self.api_version}, None
1318
 
                 ).AndRaise(rpc_common.RemoteError("Exception"))
 
1275
                 ).AndRaise(Exception())
1319
1276
 
1320
1277
        self.m.ReplayAll()
1321
1278
 
1337
1294
                  'method': 'identify_stack',
1338
1295
                  'args': {'stack_name': stack_name},
1339
1296
                  'version': self.api_version}, None
1340
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1297
                 ).AndRaise(heat_exception.StackNotFound())
1341
1298
 
1342
1299
        self.m.ReplayAll()
1343
1300
 
1364
1321
                           u'path': u'resources/WikiDatabase'
1365
1322
                       },
1366
1323
                       u'stack_name': u'wordpress',
1367
 
                       u'logical_resource_id': u'WikiDatabase',
 
1324
                       u'resource_name': u'WikiDatabase',
1368
1325
                       u'resource_status_reason': None,
1369
1326
                       u'updated_time': u'2012-07-23T13:06:00Z',
1370
1327
                       u'stack_identity': {u'tenant': u't',
1432
1389
                  'method': 'identify_stack',
1433
1390
                  'args': {'stack_name': stack_name},
1434
1391
                  'version': self.api_version},
1435
 
                 None).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1392
                 None).AndRaise(heat_exception.StackNotFound())
1436
1393
 
1437
1394
        self.m.ReplayAll()
1438
1395
 
1466
1423
                  'method': 'describe_stack_resource',
1467
1424
                  'args': args,
1468
1425
                  'version': self.api_version},
1469
 
                 None).AndRaise(rpc_common.RemoteError("ResourceNotFound"))
 
1426
                 None).AndRaise(heat_exception.ResourceNotFound())
1470
1427
 
1471
1428
        self.m.ReplayAll()
1472
1429
 
1493
1450
                            u'path': u'resources/WikiDatabase'
1494
1451
                        },
1495
1452
                        u'stack_name': u'wordpress',
1496
 
                        u'logical_resource_id': u'WikiDatabase',
 
1453
                        u'resource_name': u'WikiDatabase',
1497
1454
                        u'resource_status_reason': None,
1498
1455
                        u'updated_time': u'2012-07-23T13:06:00Z',
1499
1456
                        u'stack_identity': {u'tenant': u't',
1559
1516
                  'method': 'identify_stack',
1560
1517
                  'args': {'stack_name': stack_name},
1561
1518
                  'version': self.api_version}, None
1562
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1519
                 ).AndRaise(heat_exception.StackNotFound())
1563
1520
 
1564
1521
        self.m.ReplayAll()
1565
1522
 
1586
1543
                            u'path': u'resources/WikiDatabase'
1587
1544
                        },
1588
1545
                        u'stack_name': u'wordpress',
1589
 
                        u'logical_resource_id': u'WikiDatabase',
 
1546
                        u'resource_name': u'WikiDatabase',
1590
1547
                        u'resource_status_reason': None,
1591
1548
                        u'updated_time': u'2012-07-23T13:06:00Z',
1592
1549
                        u'stack_identity': {u'tenant': u't',
1656
1613
                           'aaaaaaaa-9f88-404d-cccc-ffffffffffff'},
1657
1614
                  'version': self.api_version},
1658
1615
                 None).AndRaise(
1659
 
                     rpc_common.RemoteError("PhysicalResourceNotFound"))
 
1616
                     heat_exception.PhysicalResourceNotFound())
1660
1617
 
1661
1618
        self.m.ReplayAll()
1662
1619
 
1695
1652
                         u'stack_id': u'6',
1696
1653
                         u'path': u'/resources/WikiDatabase'},
1697
1654
                        u'stack_name': u'wordpress',
1698
 
                        u'logical_resource_id': u'WikiDatabase',
 
1655
                        u'resource_name': u'WikiDatabase',
1699
1656
                        u'resource_status_reason': None,
1700
1657
                        u'updated_time': u'2012-07-23T13:06:00Z',
1701
1658
                        u'stack_identity': {u'tenant': u't',
1751
1708
                  'method': 'identify_stack',
1752
1709
                  'args': {'stack_name': stack_name},
1753
1710
                  'version': self.api_version}, None
1754
 
                 ).AndRaise(rpc_common.RemoteError("StackNotFound"))
 
1711
                 ).AndRaise(heat_exception.StackNotFound())
1755
1712
 
1756
1713
        self.m.ReplayAll()
1757
1714
 
1778
1735
            bind_port = 8000
1779
1736
        cfgopts = DummyConfig()
1780
1737
        self.controller = stacks.StackController(options=cfgopts)
 
1738
        self.controller.policy.enforcer.policy_path = (policy_path +
 
1739
                                                       'deny_stack_user.json')