gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/xenserver/requests/compute/create_server.rb

@@ -7,6 +7,10 @@ module Fog
           @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.get_by_name_label' }, label)
         end
         
+        def get_vm_by_uuid(uuid)
+          @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.get_by_uuid' }, uuid)
+        end
+
         def create_server_raw(config = {})
           config[:name_label] = config[:name] if config[:name]
           config.delete :name

data/lib/fog/xml/sax_parser_connection.rb

@@ -26,12 +26,15 @@ module Fog
 
         # Prepare the SAX parser
         data_stream = Nokogiri::XML::SAX::PushParser.new(parser)
+        response_string = ""
         params[:response_block] = lambda do |chunk, remaining, total|
+          response_string << chunk if ENV['DEBUG_RESPONSE']
           data_stream << chunk
         end
 
         # Make request which read chunks into parser
         response = @excon.request(params)
+        Fog::Logger.debug "\n#{response_string}" if ENV['DEBUG_RESPONSE']
 
         # Cease parsing and override response.body with parsed data
         data_stream.finish

data/lib/tasks/changelog_task.rb

@@ -58,8 +58,10 @@ module Fog
               'Christopher Oliver',
               'Decklin Foster',
               'Dylan Egan',
+              'Erik Michaels-Ober',
               'geemus',
               'Henry Addison',
+              'James Bence',
               'Kevin Menard',
               'Kyle Rames',
               'Lincoln Stoll',

data/tests/aws/models/compute/volume_tests.rb

@@ -14,7 +14,7 @@ Shindo.tests("Fog::Compute[:aws] | volume", ['aws']) do
     @instance.wait_for { state == 'in-use' }
 
     tests('#server').succeeds do
-      @instance.server
+      @instance.server.id == @server.id
     end
 
     tests('#server = nil').succeeds do

data/tests/aws/models/elb/model_tests.rb

@@ -83,7 +83,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
 
       # Need to sleep here for IAM changes to propgate
       tests('with ListenerDescriptions') do
-        @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+        @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
         sleep(10) unless Fog.mocking?
         listeners = [{
             'Listener' => {
@@ -250,6 +250,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       tests('create app policy') do
         elb.policies.create(:id => app_policy_id, :cookie => 'my-app-cookie', :cookie_stickiness => :app)
         returns(app_policy_id) { elb.policies.first.id }
+        returns("my-app-cookie") { elb.policies.get(app_policy_id).cookie }
       end
 
       tests('get policy') do
@@ -270,6 +271,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       tests('setting a listener policy') do
         elb.set_listener_policy(80, lb_policy_id)
         returns([lb_policy_id]) { elb.listeners.get(80).policy_names }
+        returns(600) { elb.policies.get(lb_policy_id).expiration }
       end
 
       tests('unsetting a listener policy') do
@@ -277,11 +279,36 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
         returns([]) { elb.listeners.get(80).policy_names }
       end
 
+      public_key_policy_id = 'fog-public-key-policy'
+      tests('create public key policy') do
+        elb.policies.create(:id => public_key_policy_id, :type_name => 'PublicKeyPolicyType', :policy_attributes => {'PublicKey' => AWS::IAM::SERVER_CERT_PUBLIC_KEY})
+        policy = elb.policies.get(public_key_policy_id)
+
+        returns(public_key_policy_id) { policy.id }
+        returns("PublicKeyPolicyType") { policy.type_name }
+        returns(AWS::IAM::SERVER_CERT_PUBLIC_KEY) { policy.policy_attributes["PublicKey"] }
+      end
+
       tests('a malformed policy') do
         raises(ArgumentError) { elb.policies.create(:id => 'foo', :cookie_stickiness => 'invalid stickiness') }
       end
     end
 
+    tests('backend server descriptions') do
+      tests('default') do
+        returns(0) { elb.backend_server_descriptions.size }
+      end
+
+      tests('with a backend policy') do
+        policy = "EnableProxyProtocol"
+        port = 80
+        elb.policies.create(:id => policy, :type_name => 'ProxyProtocolPolicyType', :policy_attributes => { "ProxyProtocol" => true })
+        Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(elb.id, port, [policy]).body
+        elb.reload
+        returns([policy]) { elb.backend_server_descriptions.get(port).policy_names }
+      end
+    end
+
     tests('setting a new ssl certificate id') do
       elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'HTTPS', :instance_protocol => 'HTTPS', :ssl_id => @certificate['Arn'])
       elb.set_listener_ssl_certificate(443, @certificate['Arn'])

data/tests/aws/models/rds/instance_option_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests("AWS::RDS | db instance options", ['aws', 'rds']) do
+
+  params = {:engine => 'mysql'}
+
+  pending if Fog.mocking?
+
+  tests('#options') do
+    tests 'contains options' do
+      @instance = Fog::AWS[:rds].instance_options.new(params)
+      returns(true) { @instance.engine == 'mysql' }
+    end
+  end
+
+end

data/tests/aws/parsers/elb/describe_load_balancers.rb

@@ -0,0 +1,65 @@
+require 'fog/xml'
+require 'fog/aws/parsers/elb/describe_load_balancers'
+
+DESCRIBE_LOAD_BALANCERS_RESULT = <<-EOF
+<DescribeLoadBalancersResponse
+xmlns="http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/">
+  <DescribeLoadBalancersResult>
+    <LoadBalancerDescriptions>
+      <member>
+        <SecurityGroups/>
+        <CreatedTime>2013-08-01T15:47:20.930Z</CreatedTime>
+        <LoadBalancerName>fog-test-elb</LoadBalancerName>
+        <HealthCheck>
+          <Interval>30</Interval>
+          <Target>TCP:80</Target>
+          <HealthyThreshold>10</HealthyThreshold>
+          <Timeout>5</Timeout>
+          <UnhealthyThreshold>2</UnhealthyThreshold>
+        </HealthCheck>
+        <ListenerDescriptions>
+          <member>
+            <PolicyNames/>
+            <Listener>
+              <Protocol>HTTP</Protocol>
+              <LoadBalancerPort>80</LoadBalancerPort>
+              <InstanceProtocol>HTTP</InstanceProtocol>
+              <InstancePort>80</InstancePort>
+            </Listener>
+          </member>
+        </ListenerDescriptions>
+        <Instances/>
+        <Policies>
+          <AppCookieStickinessPolicies/>
+          <OtherPolicies/>
+          <LBCookieStickinessPolicies/>
+        </Policies>
+        <AvailabilityZones>
+          <member>us-east-1a</member>
+        </AvailabilityZones>
+        <CanonicalHostedZoneName>fog-test-elb-1965660309.us-east-1.elb.amazonaws.com</CanonicalHostedZoneName>
+        <CanonicalHostedZoneNameID>Z3DZXE0Q79N41H</CanonicalHostedZoneNameID>
+        <Scheme>internet-facing</Scheme>
+        <SourceSecurityGroup>
+          <OwnerAlias>amazon-elb</OwnerAlias>
+          <GroupName>amazon-elb-sg</GroupName>
+        </SourceSecurityGroup>
+        <DNSName>fog-test-elb-1965660309.us-east-1.elb.amazonaws.com</DNSName>
+        <BackendServerDescriptions/>
+        <Subnets/>
+      </member>
+    </LoadBalancerDescriptions>
+  </DescribeLoadBalancersResult>
+  <ResponseMetadata>
+    <RequestId>a6ea2117-fac1-11e2-abd3-1740ab4ef14e</RequestId>
+  </ResponseMetadata>
+</DescribeLoadBalancersResponse>
+EOF
+
+Shindo.tests('AWS::ELB | parsers | describe_load_balancers', ['aws', 'elb', 'parser']) do
+  tests('parses the xml').formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCERS) do
+    parser = Nokogiri::XML::SAX::Parser.new(Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new)
+    parser.parse(DESCRIBE_LOAD_BALANCERS_RESULT)
+    parser.document.response
+  end
+end

data/tests/aws/requests/elb/helper.rb

@@ -8,6 +8,7 @@ class AWS
 
       LOAD_BALANCER = {
         "AvailabilityZones" => Array,
+        "BackendServerDescriptions" => Array,
         "CanonicalHostedZoneName" => String,
         "CanonicalHostedZoneNameID" => String,
         "CreatedTime" => Time,
@@ -25,7 +26,7 @@ class AWS
           }
         }],
         "LoadBalancerName" => String,
-        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
+        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array, "OtherPolicies" => Array},
         "Scheme" => String,
         "SecurityGroups" => [Fog::Nullable::String],
         "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},

data/tests/aws/requests/elb/listener_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
 
   tests('success') do
     Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}])
-    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
 
     tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
       listeners = [

data/tests/aws/requests/elb/load_balancer_tests.rb

@@ -3,7 +3,11 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
   @key_name = 'fog-test'
 
   tests('success') do
-    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+    if (Fog::AWS[:iam].get_server_certificate(@key_name) rescue nil)
+      Fog::AWS[:iam].delete_server_certificate(@key_name)
+    end
+
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
 
     tests("#create_load_balancer").formats(AWS::ELB::Formats::CREATE_LOAD_BALANCER) do
       zones = ['us-east-1a']

data/tests/aws/requests/elb/policy_tests.rb

@@ -5,6 +5,10 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
     listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
     Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, listeners)
 
+    tests("#describe_load_balancer_policy_types").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICY_TYPES) do
+      @policy_types = Fog::AWS[:elb].describe_load_balancer_policy_types.body
+    end
+
     tests("#create_app_cookie_stickiness_policy").formats(AWS::ELB::Formats::BASIC) do
       cookie, policy = 'fog-app-cookie', 'fog-app-policy'
       Fog::AWS[:elb].create_app_cookie_stickiness_policy(@load_balancer_id, policy, cookie).body
@@ -21,17 +25,78 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
       Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy).body
     end
 
-    tests("#describe_load_balancer_policy_types").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICY_TYPES) do
-      @policy_types = Fog::AWS[:elb].describe_load_balancer_policy_types.body
-    end
-
     tests("#create_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
       policy = 'fog-policy'
       Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, policy, 'PublicKeyPolicyType', {'PublicKey' => AWS::IAM::SERVER_CERT_PUBLIC_KEY}).body
     end
 
-    tests("#describe_load_balancer_policies").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICIES) do
-      Fog::AWS[:elb].describe_load_balancer_policies(@load_balancer_id).body
+    tests("#describe_load_balancer_policies") do
+      body = Fog::AWS[:elb].describe_load_balancer_policies(@load_balancer_id).body
+      formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICIES) { body }
+
+      # Check the result of each policy by name
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieName",
+                                                  "AttributeValue"=>"fog-app-cookie"
+                                                }],
+                "PolicyName"=>"fog-app-policy",
+                "PolicyTypeName"=>"AppCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|e| e['PolicyName'] == 'fog-app-policy' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"300"
+                                                }],
+                "PolicyName"=>"fog-lb-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|e| e['PolicyName'] == 'fog-lb-expiry' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"0"
+                                                }],
+                "PolicyName"=>"fog-lb-no-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|e| e['PolicyName'] == 'fog-lb-no-expiry' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"PublicKey",
+                                                  "AttributeValue"=> AWS::IAM::SERVER_CERT_PUBLIC_KEY
+                                                }],
+                "PolicyName"=>"fog-policy",
+                "PolicyTypeName"=>"PublicKeyPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|e| e['PolicyName'] == 'fog-policy' }
+      end
+    end
+
+    tests("#describe_load_balancer includes all policies") do
+      lb = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
+      returns([
+               {"PolicyName"=>"fog-app-policy", "CookieName"=>"fog-app-cookie"}
+              ]) { lb["Policies"]["AppCookieStickinessPolicies"] }
+
+      returns([
+               {"PolicyName"=>"fog-lb-expiry", "CookieExpirationPeriod"=> 300}
+              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-expiry"} }
+
+      returns([
+               {"PolicyName" => "fog-lb-no-expiry"}
+              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-no-expiry"} }
+
+      returns([
+               "fog-policy"
+              ]) { lb["Policies"]["OtherPolicies"] }
     end
 
     tests("#delete_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
@@ -49,6 +114,20 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
       Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
     end
 
+    proxy_policy = "EnableProxyProtocol"
+    Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, proxy_policy, 'ProxyProtocolPolicyType', { "ProxyProtocol" => true })
+
+    tests("#set_load_balancer_policies_for_backend_server replaces policies on port").formats(AWS::ELB::Formats::BASIC) do
+      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
+    end
+
+    tests("#describe_load_balancers has other policies") do
+      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
+      description = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
+      returns(true) { description["Policies"]["OtherPolicies"].include?(proxy_policy) }
+    end
+    
     Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
   end
 end
+

data/tests/aws/requests/iam/helper.rb

@@ -4,7 +4,7 @@ class AWS
     # A self-signed test keypair. Generated using the command:
     # openssl req -new -newkey rsa:1024 -days 3650 -nodes -x509 -keyout server-private.key -out server-public.crt
     # NB: Amazon returns an error on extraneous linebreaks
-    SERVER_CERT_PUBLIC_KEY = %{-----BEGIN CERTIFICATE-----
+    SERVER_CERT = %{-----BEGIN CERTIFICATE-----
 MIIDQzCCAqygAwIBAgIJAJaZ8wH+19AtMA0GCSqGSIb3DQEBBQUAMHUxCzAJBgNV
 BAYTAlVTMREwDwYDVQQIEwhOZXcgWW9yazERMA8GA1UEBxMITmV3IFlvcmsxHzAd
 BgNVBAoTFkZvZyBUZXN0IFNuYWtlb2lsIENlcnQxHzAdBgNVBAsTFkZvZyBUZXN0
@@ -25,6 +25,9 @@ DF3qnnPyArLFx0HLB7wQdm9xYVIqQuLO+V6GRuOd+uSX//aDLDZhwbERf35hoyto
 Jfk4gX/qwuRFNy0vjQeTzdvhB1igG/w=
 -----END CERTIFICATE-----
 }
+    # The public key for SERVER_CERT. Generated using the command:
+    # openssl x509 -inform pem -in server-public.crt -pubkey -noout > server.pubkey
+    SERVER_CERT_PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPctxPL5U4vaMxQUboLPr+9oL+9fSYN31VzDD4hyaeGoeI5fhnGeqk71kq5uHONBOQUMbZbBQ8PVd9Sdk+y9JJ6E5fC+GhLL5I+y2DK7syBzyymq1Wi6rPp1XXF7AQIDAQAB"
 
     SERVER_CERT_PRIVATE_KEY = %{-----BEGIN RSA PRIVATE KEY-----
 MIICXAIBAAKBgQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPct

data/tests/aws/requests/iam/server_certificate_tests.rb

@@ -25,7 +25,7 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   }
 
   tests('#upload_server_certificate') do
-    public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
+    public_key  = AWS::IAM::SERVER_CERT
     private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
     private_key_pkcs8 = AWS::IAM::SERVER_CERT_PRIVATE_KEY_PKCS8
     private_key_mismatch = AWS::IAM::SERVER_CERT_PRIVATE_KEY_MISMATCHED
@@ -68,7 +68,7 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   end
 
   tests('#update_server_certificate') do
-    public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
+    public_key  = AWS::IAM::SERVER_CERT
     private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
     key_name    = "update-key"
 

data/tests/aws/requests/rds/helper.rb

@@ -8,6 +8,11 @@ class AWS
         'ResponseMetadata' => {'RequestId' => String}
       }
 
+      DB_AVAILABILITY_ZONE_OPTION = {
+          'Name' => String,
+          'ProvisionedIopsCapable' => Fog::Boolean
+      }
+
       DB_PARAMETER_GROUP = {
           'DBParameterGroupFamily' => String,
           'DBParameterGroupName'=> String,
@@ -79,6 +84,23 @@ class AWS
         }
       }
 
+      ORDERABLE_DB_INSTANCE_OPTION = {
+          'MultiAZCapable' => Fog::Boolean,
+          'Engine' => String,
+          'LicenseModel' => String,
+          'ReadReplicaCapable' => Fog::Boolean,
+          'EngineVersion' => String,
+          'AvailabilityZones' => [DB_AVAILABILITY_ZONE_OPTION],
+          'DBInstanceClass' => String,
+          'Vpc' => Fog::Boolean
+      }
+
+      DESCRIBE_ORDERABLE_DB_INSTANCE_OPTION = BASIC.merge({
+          'DescribeOrderableDBInstanceOptionsResult' =>{
+              'OrderableDBInstanceOptions' => [ORDERABLE_DB_INSTANCE_OPTION]
+          }
+      })
+
       MODIFY_PARAMETER_GROUP = BASIC.merge({
         'ModifyDBParameterGroupResult' => {
           'DBParameterGroupName' => String
@@ -105,6 +127,19 @@ class AWS
 
       })
 
+      DB_LOG_FILE = {
+        'LastWritten' => Time,
+        'Size' => Integer,
+        'LogFileName' => String
+      }
+
+      DESCRIBE_DB_LOG_FILES = BASIC.merge({
+        'DescribeDBLogFilesResult' => {
+          'Marker' => Fog::Nullable::String,
+          'DBLogFiles' => [DB_LOG_FILE]
+        }
+      })
+
       SNAPSHOT={
         'AllocatedStorage' => Integer,
         'AvailabilityZone' => String,

data/tests/aws/requests/rds/instance_option_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('AWS::RDS | db instance option requests', ['aws', 'rds']) do
+  tests('success') do
+
+    tests("#describe_orderable_db_instance_options('mysql)").formats(AWS::RDS::Formats::DESCRIBE_ORDERABLE_DB_INSTANCE_OPTION) do
+
+      body = Fog::AWS[:rds].describe_orderable_db_instance_options('mysql').body
+
+      returns(2) {body['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'].length}
+
+      group = body['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'].first
+      returns( true ) { group['MultiAZCapable'] }
+      returns( 'mysql' ) { group['Engine'] }
+      returns( true ) { group['ReadReplicaCapable'] }
+      returns( true ) { group['AvailabilityZones'].length >= 1 }
+
+      body
+    end
+
+  end
+
+end