fog 1.1.1 → 1.2.0

data/lib/fog/aws/requests/beanstalk/validate_configuration_settings.rb

@@ -0,0 +1,33 @@
+module Fog
+  module AWS
+    class ElasticBeanstalk
+      class Real
+
+        require 'fog/aws/parsers/beanstalk/validate_configuration_settings'
+
+        # Updates the specified configuration template to have the specified properties or configuration option values.
+        #
+        # ==== Options
+        # * ApplicationName<~String>: If specified, AWS Elastic Beanstalk restricts the returned descriptions
+        #   to include only those that are associated with this application.
+        # * VersionLabel<~String>:
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/elasticbeanstalk/latest/api/API_CreateConfigurationTemplate.html
+        #
+        def validate_configuration_settings(options={})
+          if option_settings = options.delete('OptionSettings')
+            options.merge!(AWS.indexed_param('OptionSettings.member.%d', [*option_settings]))
+          end
+          request({
+                      'Operation'    => 'ValidateConfigurationSettings',
+                      :parser     => Fog::Parsers::AWS::ElasticBeanstalk::ValidateConfigurationSettings.new
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/allocate_address.rb

@@ -7,6 +7,8 @@ module Fog
 
         # Acquire an elastic IP address.
         #
+        # ==== Parameters
+        # * domain<~String> - Type of EIP, either standard or vpc
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
@@ -14,9 +16,11 @@ module Fog
         #     * 'requestId'<~String> - Id of the request
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AllocateAddress.html]
-        def allocate_address
+        def allocate_address(domain='standard')
+          domain = domain == 'vpc' ? 'vpc' : 'standard'
           request(
             'Action'  => 'AllocateAddress',
+            'Domain'  => domain,
             :parser   => Fog::Parsers::Compute::AWS::AllocateAddress.new
           )
         end
@@ -25,17 +29,20 @@ module Fog
 
       class Mock
 
-        def allocate_address
+        def allocate_address(domain = 'standard')
+          domain = domain == 'vpc' ? 'vpc' : 'standard'
           response = Excon::Response.new
           if describe_addresses.body['addressesSet'].size < self.data[:limits][:addresses]
             response.status = 200
             public_ip = Fog::AWS::Mock.ip_address
-            data ={
+            data = {
               'instanceId' => nil,
-              'publicIp'   => public_ip
+              'publicIp'   => public_ip,
+              'domain'     => domain
             }
             self.data[:addresses][public_ip] = data
             response.body = {
+              'domain'    => domain,
               'publicIp'  => public_ip,
               'requestId' => Fog::AWS::Mock.request_id
             }

data/lib/fog/aws/requests/compute/associate_address.rb

@@ -3,28 +3,36 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/parsers/compute/basic'
+        require 'fog/aws/parsers/compute/associate_address'
 
         # Associate an elastic IP address with an instance
         #
         # ==== Parameters
-        # * instance_id<~String> - Id of instance to associate address with
-        # * public_ip<~String> - Public ip to assign to instance
+        # * instance_id<~String> - Id of instance to associate address with (conditional) 
+        # * public_ip<~String> - Public ip to assign to instance (conditional)
+        # * network_interface_id<~String> - Id of a nic to associate address with (required in a vpc instance with more than one nic) (conditional)
+        # * allocation_id<~String> - Allocation Id to associate address with (vpc only) (conditional)
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     * 'requestId'<~String> - Id of request
         #     * 'return'<~Boolean> - success?
+        #     * 'associationId'<~String> - association Id for eip to node (vpc only)
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateAddress.html]
-        def associate_address(instance_id, public_ip)
+        def associate_address(instance_id=nil, public_ip=nil, network_interface_id=nil, allocation_id=nil)
+          # Cannot specify an allocation ip and a public IP at the same time.  If you have an allocation Id presumably you are in a VPC
+          # so we will null out the public IP
+          public_ip = allocation_id.nil? ? public_ip : nil
           request(
-            'Action'      => 'AssociateAddress',
-            'InstanceId'  => instance_id,
-            'PublicIp'    => public_ip,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::Basic.new
+            'Action'             => 'AssociateAddress',
+            'AllocationId'       => allocation_id,
+            'InstanceId'         => instance_id,
+            'NetworkInterfaceId' => network_interface_id,
+            'PublicIp'           => public_ip,
+            :idempotent          => true,
+            :parser              => Fog::Parsers::Compute::AWS::AssociateAddress.new
           )
         end
 
@@ -32,12 +40,17 @@ module Fog
 
       class Mock
 
-        def associate_address(instance_id, public_ip)
+        def associate_address(instance_id=nil, public_ip=nil, network_interface_id=nil, allocation_id=nil)
+          public_ip = allocation_id.nil? ? public_ip : nil
           response = Excon::Response.new
           response.status = 200
           instance = self.data[:instances][instance_id]
-          address = self.data[:addresses][public_ip]
-          if instance && address
+          address = public_ip.nil? ? nil : self.data[:addresses][public_ip]
+          if ((instance && address) || (instance &&  !allocation_id.nil?) || (!allocation_id.nil? && !network_interface_id.nil?))
+            if !allocation_id.nil?
+              allocation_ip = describe_addresses( 'allocation-id'  => "#{allocation_id}").body['addressesSet']
+              public_ip = allocation_ip['publicIp']
+            end
             if current_instance = self.data[:instances][address['instanceId']]
               current_instance['ipAddress'] = current_instance['originalIpAddress']
             end
@@ -49,13 +62,27 @@ module Fog
             instance['ipAddress'] = public_ip
             instance['dnsName'] = Fog::AWS::Mock.dns_name_for(public_ip)
             response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
+            if !instance_id.nil? && !public_ip.nil?
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'return'    => true
+              }
+            elsif !allocation_id.nil?
+              response.body = {
+                'requestId'     => Fog::AWS::Mock.request_id,
+                'return'        => true,
+                'associationId' => Fog::AWS::Mock.request_id
+              }
+            end
             response
+          #elsif ! network_interface_id.nil? && allocation_id.nil?
+          #  raise Fog::Compute::AWS::NotFound.new("You must specify an AllocationId when specifying a NetworkInterfaceID")
+          #elsif instance.nil? && network_interface_id.nil?
+          #  raise Fog::Compute::AWS::Error.new("You must specify either an InstanceId or a NetworkInterfaceID")
+          #elsif !instance && !network_interface_id
+          #  raise Fog::Compute::AWS::Error.new(" 2 You must specify either an InstanceId or a NetworkInterfaceID")
           elsif !instance
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+            raise Fog::Compute::AWS::NotFound.new("You must specify either an InstanceId or a NetworkInterfaceID")
           elsif !address
             raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
           end

data/lib/fog/aws/requests/compute/authorize_security_group_ingress.rb

@@ -8,8 +8,10 @@ module Fog
         # Add permissions to a security group
         #
         # ==== Parameters
-        # * group_name<~String> - Name of group
+        # * group_name<~String> - Name of group, optional (can also be specifed as GroupName in options)
         # * options<~Hash>:
+        #   * 'GroupName'<~String> - Name of security group to modify
+        #   * 'GroupId'<~String> - Id of security group to modify
         #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
         #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
         #   or
@@ -39,11 +41,7 @@ module Fog
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AuthorizeSecurityGroupIngress.html]
         def authorize_security_group_ingress(group_name, options = {})
-          if group_name.is_a?(Hash)
-            Fog::Logger.deprecation("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
-            options = group_name
-            group_name = options.delete('GroupName')
-          end
+          options = Fog::AWS.parse_security_group_options(group_name, options)
 
           if ip_permissions = options.delete('IpPermissions')
             options.merge!(indexed_ip_permissions_params(ip_permissions))
@@ -51,7 +49,6 @@ module Fog
 
           request({
             'Action'    => 'AuthorizeSecurityGroupIngress',
-            'GroupName' => group_name,
             :idempotent => true,
             :parser     => Fog::Parsers::Compute::AWS::Basic.new
           }.merge!(options))
@@ -85,18 +82,19 @@ module Fog
       class Mock
 
         def authorize_security_group_ingress(group_name, options = {})
-          if group_name.is_a?(Hash)
-            Fog::Logger.deprecation("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
-            options = group_name
-            group_name = options.delete('GroupName')
+          options = Fog::AWS.parse_security_group_options(group_name, options)
+          if options.key?('GroupName')
+            group_name = options['GroupName']
+          else
+            group_name = self.data[:security_groups].reject { |k,v| v['groupId'] != options['GroupId'] } .keys.first
           end
 
-          verify_permission_options(options)
-
           response = Excon::Response.new
           group = self.data[:security_groups][group_name]
 
           if group
+            verify_permission_options(options, group['vpcId'] != nil)
+            
             normalized_permissions = normalize_permissions(options)
 
             normalized_permissions.each do |permission|
@@ -133,11 +131,11 @@ module Fog
 
         private
 
-        def verify_permission_options(options)
-          if options.empty?
+        def verify_permission_options(options, is_vpc)
+          if options.size <= 1
             raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
           end
-          if options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol'])
+          if !is_vpc && options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol'])
             raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\"  - supported: [tcp, udp, icmp]")
           end
           if options['IpProtocol'] && (!options['FromPort'] || !options['ToPort'])
@@ -147,7 +145,7 @@ module Fog
             if !options['IpPermissions'].is_a?(Array) || options['IpPermissions'].empty?
               raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
             end
-            options['IpPermissions'].each {|p| verify_permission_options(p) }
+            options['IpPermissions'].each {|p| verify_permission_options(p, is_vpc) }
           end
         end
 

data/lib/fog/aws/requests/compute/create_security_group.rb

@@ -10,6 +10,7 @@ module Fog
         # ==== Parameters
         # * group_name<~String> - Name of the security group.
         # * group_description<~String> - Description of group.
+        # * vpc_id<~String> - ID of the VPC
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -18,12 +19,13 @@ module Fog
         #     * 'return'<~Boolean> - success?
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateSecurityGroup.html]
-        def create_security_group(name, description)
+        def create_security_group(name, description, vpc_id=nil)
           request(
             'Action'            => 'CreateSecurityGroup',
             'GroupName'         => name,
             'GroupDescription'  => description,
-            :parser             => Fog::Parsers::Compute::AWS::Basic.new
+            :parser             => Fog::Parsers::Compute::AWS::Basic.new,
+            'VpcId'             => vpc_id
           )
         end
 
@@ -31,15 +33,17 @@ module Fog
 
       class Mock
 
-        def create_security_group(name, description)
+        def create_security_group(name, description, vpc_id=nil)
           response = Excon::Response.new
           unless self.data[:security_groups][name]
             data = {
               'groupDescription'    => description,
               'groupName'           => name,
+              'groupId'             => Fog::AWS::Mock.security_group_id,
               'ipPermissionsEgress' => [],
               'ipPermissions'       => [],
-              'ownerId'             => self.data[:owner_id]
+              'ownerId'             => self.data[:owner_id],
+              'vpcId'               => vpc_id
             }
             self.data[:security_groups][name] = data
             response.body = {

data/lib/fog/aws/requests/compute/create_subnet.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/create_subnet'
+
+        # Creates a Subnet with the CIDR block you specify.
+        #
+        # ==== Parameters
+        # * vpcId<~String> - The ID of the VPC where you want to create the subnet.
+        # * cidrBlock<~String> - The CIDR block you want the Subnet to cover (e.g., 10.0.0.0/16).
+        # * options<~Hash>:
+        #   * AvailabilityZone<~String> - The Availability Zone you want the subnet in. Default: AWS selects a zone for you (recommended)
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'subnet'<~Array>:
+        # * 'subnetId'<~String> - The Subnet's ID
+        # * 'state'<~String> - The current state of the Subnet. ['pending', 'available']
+        # * 'cidrBlock'<~String> - The CIDR block the Subnet covers.
+        # * 'AvailableIpAddressCount'<~Integer> - The number of unused IP addresses in the subnet (the IP addresses for any stopped 
+        #   instances are considered unavailable)
+        # * 'AvailabilityZone'<~String> - The Availability Zone the subnet is in
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        # * 'key'<~String> - Tag's key
+        # * 'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/ApiReference-query-CreateSubnet.html]
+        def create_subnet(vpcId, cidrBlock, options = {})
+          request({
+            'Action'     => 'CreateSubnet',
+            'VpcId'      => vpcId,
+            'CidrBlock'  => cidrBlock,
+            :parser      => Fog::Parsers::Compute::AWS::CreateSubnet.new
+          }.merge!(options))
+
+        end
+      end
+      
+      class Mock
+        def create_subnet(vpcId, cidrBlock, options = {})
+          av_zone = options['AvailabilityZone'].nil? ? 'us-east-1c' : options['AvailabilityZone']
+          Excon::Response.new.tap do |response|
+            if cidrBlock  && vpcId
+              response.status = 200
+            
+              response.body = {
+                'requestId'    => Fog::AWS::Mock.request_id,
+                'subnetSet'    => [
+                  'subnetId'                 => Fog::AWS::Mock.request_id,
+                  'state'                    => 'pending',
+                  'vpcId'                    => Fog::AWS::Mock.request_id,
+                  'cidrBlock'                => cidrBlock,
+                  'availableIpAddressCount'  => 16,
+                  'availabilityZone'         => av_zone,
+                  'tagSet'                   => {}
+                ]
+              }
+            else
+              response.status = 400
+              response.body = {
+                'Code' => 'InvalidParameterValue'
+              }
+              if cidrBlock.empty?
+                response.body['Message'] = "Invalid value '' for cidrBlock. Must be specified."
+              end
+              if vpcId.empty?
+                response.body['Message'] = "Invalid value '' for vpcId. Must be specified."
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/create_tags.rb

@@ -30,8 +30,9 @@ module Fog
           params.merge!(Fog::AWS.indexed_param('Tag.%d.Key', tags.keys))
           params.merge!(Fog::AWS.indexed_param('Tag.%d.Value', tags.values))
           request({
-            'Action'            => 'CreateTags',
-            :parser             => Fog::Parsers::Compute::AWS::Basic.new
+            'Action'    => 'CreateTags',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
           }.merge!(params))
         end
 

data/lib/fog/aws/requests/compute/create_vpc.rb

@@ -0,0 +1,71 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/create_vpc'
+
+        # Creates a VPC with the CIDR block you specify.
+        #
+        # ==== Parameters
+        # * cidrBlock<~String> - The CIDR block you want the VPC to cover (e.g., 10.0.0.0/16).
+        # * options<~Hash>:
+        #   * InstanceTenancy<~String> - The allowed tenancy of instances launched into the VPC. A value of default 
+        #     means instances can be launched with any tenancy; a value of dedicated means instances must be launched with tenancy as dedicated.
+        #     please not that the documentation is incorrect instanceTenancy will not work while InstanceTenancy will
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'vpc'<~Array>:
+        # * 'vpcId'<~String> - The VPC's ID
+        # * 'state'<~String> - The current state of the VPC. ['pending', 'available']
+        # * 'cidrBlock'<~String> - The CIDR block the VPC covers.
+        # * 'dhcpOptionsId'<~String> - The ID of the set of DHCP options.
+        # * 'tagSet'<~Array>: Tags assigned to the resource.
+        # * 'key'<~String> - Tag's key
+        # * 'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-CreateVpc.html]
+        def create_vpc(cidrBlock, options = {})
+          request({
+            'Action' => 'CreateVpc',
+            'CidrBlock' => cidrBlock,
+            :parser => Fog::Parsers::Compute::AWS::CreateVpc.new
+          }.merge!(options))
+
+        end
+      end
+      
+      class Mock
+        def create_vpc(cidrBlock)
+          Excon::Response.new.tap do |response|
+            if cidrBlock 
+              response.status = 200
+            
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'vpcSet'    => [
+                  'vpcId'         => Fog::AWS::Mock.request_id,
+                  'state'         => 'pending',
+                  'cidrBlock'     => cidrBlock,
+                  'dhcpOptionsId' => Fog::AWS::Mock.request_id,
+                  'tagSet'        => {}
+                ]
+              }
+            else
+              response.status = 400
+              response.body = {
+                'Code' => 'InvalidParameterValue'
+              }
+              if cidrBlock.empty?
+                response.body['Message'] = "Invalid value '' for cidrBlock. Must be specified."
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/delete_security_group.rb

@@ -8,7 +8,8 @@ module Fog
         # Delete a security group that you own
         #
         # ==== Parameters
-        # * group_name<~String> - Name of the security group.
+        # * group_name<~String> - Name of the security group, must be nil if id is specified
+        # * group_id<~String> - Id of the security group, must be nil if name is specified
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -17,10 +18,20 @@ module Fog
         #     * 'return'<~Boolean> - success?
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DeleteSecurityGroup.html]
-        def delete_security_group(name)
+        def delete_security_group(name, id = nil)
+          if name && id
+            raise Fog::Compute::AWS::Error.new("May not specify both group_name and group_id")
+          end
+          if name
+            type_id    = 'GroupName'
+            identifier = name
+          else
+            type_id    = 'GroupId'
+            identifier = id
+          end
           request(
             'Action'    => 'DeleteSecurityGroup',
-            'GroupName' => name,
+            type_id     => identifier,
             :idempotent => true,
             :parser     => Fog::Parsers::Compute::AWS::Basic.new
           )
@@ -29,11 +40,18 @@ module Fog
       end
 
       class Mock
-        def delete_security_group(name)
+        def delete_security_group(name, id = nil)
           if name == 'default'
             raise Fog::Compute::AWS::Error.new("InvalidGroup.Reserved => The security group 'default' is reserved")
           end
 
+          if name && id
+            raise Fog::Compute::AWS::Error.new("May not specify both group_name and group_id")
+          end
+          if id
+            name = self.data[:security_groups].reject { |k,v| v['groupId'] != id } .keys.first
+          end
+
           response = Excon::Response.new
           if self.data[:security_groups][name]
 

data/lib/fog/aws/requests/compute/delete_subnet.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/delete_subnet'
+        # Deletes a subnet from a VPC. You must terminate all running instances in the subnet before deleting it, otherwise Amazon 
+        # VPC returns an error
+        #
+        # ==== Parameters
+        # * subnet_id<~String> - The ID of the Subnet you want to delete.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/ApiReference-query-DeleteSubnet.html]
+        def delete_subnet(subnet_id)
+          request(
+            'Action' => 'DeleteSubnet',
+            'SubnetId' => subnet_id,
+            :parser => Fog::Parsers::Compute::AWS::DeleteSubnet.new
+          )
+        end
+      end
+      
+      class Mock
+        def delete_subnet(subnet_id)
+          Excon::Response.new.tap do |response|
+            if subnet_id
+              response.status = 200
+            
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'return' => true
+              }
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain the parameter subnet_id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/delete_vpc.rb

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/delete_vpc'
+
+        # Deletes a VPC. You must detach or delete all gateways or other objects
+        # that are dependent on the VPC first. For example, you must terminate
+        # all running instances, delete all VPC security groups (except the
+        # default), delete all the route tables (except the default), etc.
+        #
+        # ==== Parameters
+        # * vpc_id<~String> - The ID of the VPC you want to delete.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'return'<~Boolean> - Returns true if the request succeeds.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2011-07-15/APIReference/index.html?ApiReference-query-DeleteVpc.html]
+        def delete_vpc(vpc_id)
+          request(
+            'Action' => 'DeleteVpc',
+            'VpcId' => vpc_id,
+            :parser => Fog::Parsers::Compute::AWS::DeleteVpc.new
+          )
+        end
+      end
+      
+      class Mock
+        def delete_vpc(vpc_id)
+          Excon::Response.new.tap do |response|
+            if vpc_id
+              response.status = 200
+            
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id,
+                'return' => true
+              }
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain the parameter vpc_id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/describe_availability_zones.rb

@@ -57,6 +57,9 @@ module Fog
 
             {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2b", "zoneState" => "available"},
+            
+            {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1a", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1b", "zoneState" => "available"},
 
             {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1b", "zoneState" => "available"},