Update checked in version of gsutil to version 4.6

third_party/boto/tests/integration/ec2/elb/test_connection.py

Index: third_party/boto/tests/integration/ec2/elb/test_connection.py
===================================================================
--- third_party/boto/tests/integration/ec2/elb/test_connection.py	(revision 33376)
+++ third_party/boto/tests/integration/ec2/elb/test_connection.py	(working copy)
@@ -24,6 +24,8 @@
 Initial, and very limited, unit tests for ELBConnection.
 """
 
+import boto
+import time
 import unittest
 from boto.ec2.elb import ELBConnection
 
@@ -39,6 +41,19 @@
         self.listeners = [(80, 8000, 'HTTP')]
         self.balancer = self.conn.create_load_balancer(self.name, self.availability_zones, self.listeners)
 
+        # S3 bucket for log tests
+        self.s3 = boto.connect_s3()
+        self.timestamp = str(int(time.time()))
+        self.bucket_name = 'boto-elb-%s' % self.timestamp
+        self.bucket = self.s3.create_bucket(self.bucket_name)
+        self.bucket.set_canned_acl('public-read-write')
+        self.addCleanup(self.cleanup_bucket, self.bucket)
+
+    def cleanup_bucket(self, bucket):
+        for key in bucket.get_all_keys():
+            key.delete()
+        bucket.delete()
+
     def tearDown(self):
         """ Deletes the test load balancer after every test.
         It does not delete EVERY load balancer in your account"""
@@ -161,5 +176,95 @@
             sorted([(80, 8000, 'HTTP', 'HTTP')] + complex_listeners)
         )
 
+    def test_load_balancer_access_log(self):
+        attributes = self.balancer.get_attributes()
+
+        self.assertEqual(False, attributes.access_log.enabled)
+
+        attributes.access_log.enabled = True
+        attributes.access_log.s3_bucket_name = self.bucket_name
+        attributes.access_log.s3_bucket_prefix = 'access-logs'
+        attributes.access_log.emit_interval = 5
+
+        self.conn.modify_lb_attribute(self.balancer.name, 'accessLog',
+                                      attributes.access_log)
+
+        new_attributes = self.balancer.get_attributes()
+
+        self.assertEqual(True, new_attributes.access_log.enabled)
+        self.assertEqual(self.bucket_name,
+            new_attributes.access_log.s3_bucket_name)
+        self.assertEqual('access-logs',
+            new_attributes.access_log.s3_bucket_prefix)
+        self.assertEqual(5, new_attributes.access_log.emit_interval)
+
+    def test_load_balancer_get_attributes(self):
+        attributes = self.balancer.get_attributes()
+        connection_draining = self.conn.get_lb_attribute(self.balancer.name,
+                                                         'ConnectionDraining')
+        self.assertEqual(connection_draining.enabled,
+                         attributes.connection_draining.enabled)
+        self.assertEqual(connection_draining.timeout,
+                         attributes.connection_draining.timeout)
+
+        access_log = self.conn.get_lb_attribute(self.balancer.name,
+                                                'AccessLog')
+        self.assertEqual(access_log.enabled, attributes.access_log.enabled)
+        self.assertEqual(access_log.s3_bucket_name, attributes.access_log.s3_bucket_name)
+        self.assertEqual(access_log.s3_bucket_prefix, attributes.access_log.s3_bucket_prefix)
+        self.assertEqual(access_log.emit_interval, attributes.access_log.emit_interval)
+
+        cross_zone_load_balancing = self.conn.get_lb_attribute(self.balancer.name,
+                                                'CrossZoneLoadBalancing')
+        self.assertEqual(cross_zone_load_balancing,
+                         attributes.cross_zone_load_balancing.enabled)
+
+    def change_and_verify_load_balancer_connection_draining(self, enabled, timeout = None):
+        attributes = self.balancer.get_attributes()
+
+        attributes.connection_draining.enabled = enabled
+        if timeout != None:
+            attributes.connection_draining.timeout = timeout
+
+	self.conn.modify_lb_attribute(self.balancer.name,
+                                      'ConnectionDraining', attributes.connection_draining)
+
+        attributes = self.balancer.get_attributes()
+        self.assertEqual(enabled, attributes.connection_draining.enabled)
+        if timeout != None:
+            self.assertEqual(timeout, attributes.connection_draining.timeout)
+
+    def test_load_balancer_connection_draining_config(self):
+    	self.change_and_verify_load_balancer_connection_draining(True, 128)
+    	self.change_and_verify_load_balancer_connection_draining(True, 256)
+    	self.change_and_verify_load_balancer_connection_draining(False)
+    	self.change_and_verify_load_balancer_connection_draining(True, 64) 
+
+    def test_set_load_balancer_policies_of_listeners(self):
+        more_listeners = [(443, 8001, 'HTTP')]
+        self.conn.create_load_balancer_listeners(self.name, more_listeners)
+
+        lb_policy_name = 'lb-policy'
+        self.conn.create_lb_cookie_stickiness_policy(
+            1000,
+            self.name,
+            lb_policy_name
+        )
+        self.conn.set_lb_policies_of_listener(
+            self.name,
+            self.listeners[0][0],
+            lb_policy_name
+        )
+
+        # Try to remove the policy by passing empty list.
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_SetLoadBalancerPoliciesOfListener.html
+        # documents this as the way to remove policies.
+        self.conn.set_lb_policies_of_listener(
+            self.name,
+            self.listeners[0][0],
+            []
+        )
+
+
 if __name__ == '__main__':
     unittest.main()