providers/ec2: support VPC

juju/providers/ec2/tests/common.py

 
 from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
 
 from txaws.s3.client import S3Client
 from txaws.s3.exception import S3Error
 from txaws.ec2.client import EC2Client
 from txaws.ec2.exception import EC2Error
 from txaws.ec2.model import Instance, Reservation, SecurityGroup
 
 from juju.lib import serializer
@@ skipping 90 matching lines @@
         get_public_key(MATCH(match_config))
         self.mocker.result("zebra")
 
         get_ami_args = get_ami_args or (
             "splendid", "amd64", "us-east-1", False, False)
         get_ami = self.mocker.replace(
             "juju.providers.ec2.utils.get_current_ami")
         get_ami(*get_ami_args)
         self.mocker.result(succeed(ami_name))
 
-    def _mock_create_group(self):
+    def _mock_create_group(self, vpc_id=None):
         group_name = "juju-%s" % self.env_name
         self.ec2.create_security_group(
-            group_name, "juju group for %s" % self.env_name)
-        self.mocker.result(succeed(True))
+            group_name, "juju group for %s" % self.env_name,
+            vpc_id=vpc_id)
+        self.mocker.result(succeed("sg-a1a1a1a1"))
 
         self.ec2.authorize_security_group(
-            group_name, ip_protocol="tcp", from_port="22",
+            group_id="sg-a1a1a1a1", ip_protocol="tcp", from_port="22",
             to_port="22", cidr_ip="0.0.0.0/0")
         self.mocker.result(succeed([self.env_name]))
 
         self.ec2.describe_security_groups(group_name)
         self.mocker.result(succeed(
-            [SecurityGroup(group_name, "", owner_id="123")]))
+            [SecurityGroup("sg-a1a1a1a1", group_name, "", owner_id="123")]))
 
         self.ec2.authorize_security_group(
-            group_name, source_group_name=group_name,
+            group_id="sg-a1a1a1a1", source_group_name=group_name,
             source_group_owner_id="123")
         self.mocker.result(succeed(True))
 
-    def _mock_create_machine_group(self, machine_id):
+    def _mock_create_machine_group(self, machine_id, vpc_id=None):
         machine_group_name = "juju-%s-%s" % (self.env_name, machine_id)
         self.ec2.create_security_group(
             machine_group_name, "juju group for %s machine %s" % (
-                self.env_name, machine_id))
-        self.mocker.result(succeed(True))
+                self.env_name, machine_id), vpc_id=vpc_id)
+        self.mocker.result(succeed("sg-b2b2b2b2"))
 
     def _mock_get_zookeeper_hosts(self, hosts=None):
         """
         Try to encapsulate a variety of behaviors here..
 
         if hosts is None, a default host is used.
         if hosts is False, no s3 state is returned
         if hosts are passed as a list of instances, they
            are returned.
         """
 
         if hosts is None:
             hosts = [self.get_instance(
-                "i-es-zoo", private_dns_name="es.example.internal")]
+                "i-es-zoo", private_dns_name="es.example.internal", private_ip_address="1.1.1.1")]
 
         self.s3.get_object(self.env_name, "provider-state")
         if hosts is False:
             error = S3Error("<error/>", 404)
             error.errors = [{"Code": "NoSuchKey"}]
             self.mocker.result(fail(error))
             return
 
         state = serializer.dump({
             "zookeeper-instances":
@@ skipping 39 matching lines @@
 
 class Observed(object):
     """Minimal wrapper just to ensure :method:`add` returns a `Deferred`."""
 
     def __init__(self):
         self.items = set()
 
     def add(self, item):
         self.items.add(item)
         return succeed(True)