Update checked in version of gsutil to version 4.6

third_party/boto/tests/unit/cloudformation/test_connection.py

 #!/usr/bin/env python
 import unittest
 import httplib
 from datetime import datetime
 try:
     import json
 except ImportError:
     import simplejson as json
 
 from mock import Mock
 
 from tests.unit import AWSMockServiceTestCase
 from boto.cloudformation.connection import CloudFormationConnection
+from boto.exception import BotoServerError
 
 
 SAMPLE_TEMPLATE = r"""
 {
   "AWSTemplateFormatVersion" : "2010-09-09",
   "Description" : "Sample template",
   "Parameters" : {
     "KeyName" : {
       "Description" : "key pair",
       "Type" : "String"
@@ skipping 77 matching lines @@
         self.assert_request_parameters({
             'Action': 'CreateStack',
             'ContentType': 'JSON',
             'DisableRollback': 'false',
             'StackName': 'stack_name',
             'Version': '2010-05-15',
         })
 
     def test_create_stack_fails(self):
         self.set_http_response(status_code=400, reason='Bad Request',
-                               body='Invalid arg.')
-        with self.assertRaises(self.service_connection.ResponseError):
+            body='{"Error": {"Code": 1, "Message": "Invalid arg."}}')
+        with self.assertRaisesRegexp(self.service_connection.ResponseError,
+            'Invalid arg.'):
             api_response = self.service_connection.create_stack(
                 'stack_name', template_body=SAMPLE_TEMPLATE,
                 parameters=[('KeyName', 'myKeyName')])
 
+    def test_create_stack_fail_error(self):
+        self.set_http_response(status_code=400, reason='Bad Request',
+            body='{"RequestId": "abc", "Error": {"Code": 1, "Message": "Invalid arg."}}')
+        try:
+            api_response = self.service_connection.create_stack(
+                'stack_name', template_body=SAMPLE_TEMPLATE,
+                parameters=[('KeyName', 'myKeyName')])
+        except BotoServerError, e:
+            self.assertEqual('abc', e.request_id)
+            self.assertEqual(1, e.error_code)
+            self.assertEqual('Invalid arg.', e.message)
 
 class TestCloudFormationUpdateStack(CloudFormationConnectionBase):
     def default_body(self):
         return json.dumps(
             {u'UpdateStackResponse':
                  {u'UpdateStackResult': {u'StackId': self.stack_id},
                   u'ResponseMetadata': {u'RequestId': u'1'}}})
 
     def test_update_stack_all_args(self):
         self.set_http_response(status_code=200)
@@ skipping 435 matching lines @@
                     <ParameterKey>InstanceType</ParameterKey>
                     <Description>Type of instance to launch</Description>
                     <DefaultValue>m1.small</DefaultValue>
                   </member>
                   <member>
                     <NoEcho>false</NoEcho>
                     <ParameterKey>KeyName</ParameterKey>
                     <Description>EC2 KeyPair</Description>
                   </member>
                 </Parameters>
+                <CapabilitiesReason>Reason</CapabilitiesReason>
+                <Capabilities>
+                  <member>CAPABILITY_IAM</member>
+                </Capabilities>
               </ValidateTemplateResult>
               <ResponseMetadata>
                 <RequestId>0be7b6e8-e4a0-11e0-a5bd-9f8d5a7dbc91</RequestId>
               </ResponseMetadata>
             </ValidateTemplateResponse>
         """
 
     def test_validate_template(self):
         self.set_http_response(status_code=200)
         template = self.service_connection.validate_template(template_body=SAMPLE_TEMPLATE,
                                                           template_url='http://url')
         self.assertEqual(template.description, 'My Description.')
         self.assertEqual(len(template.template_parameters), 2)
         param1, param2 = template.template_parameters
         self.assertEqual(param1.default_value, 'm1.small')
         self.assertEqual(param1.description, 'Type of instance to launch')
         self.assertEqual(param1.no_echo, True)
         self.assertEqual(param1.parameter_key, 'InstanceType')
 
         self.assertEqual(param2.default_value, None)
         self.assertEqual(param2.description, 'EC2 KeyPair')
         self.assertEqual(param2.no_echo, True)
         self.assertEqual(param2.parameter_key, 'KeyName')
 
+        self.assertEqual(template.capabilities_reason, 'Reason')
+
+        self.assertEqual(len(template.capabilities), 1)
+        self.assertEqual(template.capabilities[0].value, 'CAPABILITY_IAM')
+
         self.assert_request_parameters({
             'Action': 'ValidateTemplate',
             'TemplateBody': SAMPLE_TEMPLATE,
             'TemplateURL': 'http://url',
             'Version': '2010-05-15',
         })
 
 
 class TestCloudFormationCancelUpdateStack(CloudFormationConnectionBase):
     def default_body(self):
         return """<CancelUpdateStackResult/>"""
 
     def test_cancel_update_stack(self):
         self.set_http_response(status_code=200)
         api_response = self.service_connection.cancel_update_stack('stack_name')
         self.assertEqual(api_response, True)
         self.assert_request_parameters({
             'Action': 'CancelUpdateStack',
             'StackName': 'stack_name',
             'Version': '2010-05-15',
         })
 
 
+class TestCloudFormationEstimateTemplateCost(CloudFormationConnectionBase):
+    def default_body(self):
+        return """
+            {
+                "EstimateTemplateCostResponse": {
+                    "EstimateTemplateCostResult": {
+                        "Url": "http://calculator.s3.amazonaws.com/calc5.html?key=cf-2e351785-e821-450c-9d58-625e1e1ebfb6"
+                    }
+                }
+            }
+        """
+
+    def test_estimate_template_cost(self):
+        self.set_http_response(status_code=200)
+        api_response = self.service_connection.estimate_template_cost(
+            template_body='{}')
+        self.assertEqual(api_response,
+            'http://calculator.s3.amazonaws.com/calc5.html?key=cf-2e351785-e821-450c-9d58-625e1e1ebfb6')
+        self.assert_request_parameters({
+            'Action': 'EstimateTemplateCost',
+            'ContentType': 'JSON',
+            'TemplateBody': '{}',
+            'Version': '2010-05-15',
+        })
+
+
+class TestCloudFormationGetStackPolicy(CloudFormationConnectionBase):
+    def default_body(self):
+        return """
+            {
+                "GetStackPolicyResponse": {
+                    "GetStackPolicyResult": {
+                        "StackPolicyBody": "{...}"
+                    }
+                }
+            }
+        """
+
+    def test_get_stack_policy(self):
+        self.set_http_response(status_code=200)
+        api_response = self.service_connection.get_stack_policy('stack-id')
+        self.assertEqual(api_response, '{...}')
+        self.assert_request_parameters({
+            'Action': 'GetStackPolicy',
+            'ContentType': 'JSON',
+            'StackName': 'stack-id',
+            'Version': '2010-05-15',
+        })
+
+
+class TestCloudFormationSetStackPolicy(CloudFormationConnectionBase):
+    def default_body(self):
+        return """
+            {
+                "SetStackPolicyResponse": {
+                    "SetStackPolicyResult": {
+                        "Some": "content"
+                    }
+                }
+            }
+        """
+
+    def test_set_stack_policy(self):
+        self.set_http_response(status_code=200)
+        api_response = self.service_connection.set_stack_policy('stack-id',
+            stack_policy_body='{}')
+        self.assertEqual(api_response['Some'], 'content')
+        self.assert_request_parameters({
+            'Action': 'SetStackPolicy',
+            'ContentType': 'JSON',
+            'StackName': 'stack-id',
+            'StackPolicyBody': '{}',
+            'Version': '2010-05-15',
+        })
+
+
 if __name__ == '__main__':
     unittest.main()