fog-maestrodev 1.14.0.20130806165225 → 1.15.0.20130829165835

data/lib/fog/vcloud/examples/more_on_vapps.md

@@ -0,0 +1,23 @@
+# More on vApps
+
+## Checking running or stopped
+
+    selected_vapp = connection.servers.service.vapps.detect { |n| n.name == 'vapp-name' }
+    selected_vapp.on?
+    selected_vapp.off?
+
+## Wait for app to come up or stop
+
+    selected_vapp.wait_for { selected_vapp.on? }
+    selected_vapp.wait_for { selected_vapp.off? }
+
+## Delete vApp
+
+    selected_vapp = connection.servers.service.vapps.detect { |n| n.name == 'vapp-name' }
+    vapp = connection.servers.service.get_vapp(selected_vapp.href)
+    if vapp.on?
+      vapp.service.undeploy selected_vapp.href #undeploy to stop vApp
+      vapp.wait_for { vapp.off? }
+    end
+    vapp.wait_for { vapp.off? } #double check
+    vapp.service.delete_vapp selected_vapp.href

data/lib/fog/version.rb

@@ -1,3 +1,3 @@
 module Fog
-  VERSION = '1.14.0'
+  VERSION = '1.15.0'
 end

data/lib/tasks/changelog_task.rb

@@ -56,6 +56,7 @@ module Fog
               'Aaron Suggs',
               'Brian Hartsock',
               'Christopher Oliver',
+              'Daniel Reichert',
               'Decklin Foster',
               'Dylan Egan',
               'Erik Michaels-Ober',

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

@@ -57,7 +57,10 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
         end
       end
       tests('with vpc') do
+        Fog::Compute[:aws].ec2_compatibility_mode(false)
         elb2 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :subnet_ids => [@subnet_id])
+        tests("elb source group should be default_elb*").returns(true) { !!(elb2.source_group["GroupName"] =~ /default_elb_*/) }
+        tests("should have a 'default_elb_*' security group").returns(true) { Fog::Compute[:aws].security_groups.all.any? { |sg| sg.name =~ /default_elb/ } }
         tests("subnet ids are correct").returns(@subnet_id) { elb2.subnet_ids.first }
         elb2.destroy
       end
@@ -75,8 +78,10 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
      end
 
       tests('with availability zones') do
+        Fog::Compute[:aws].ec2_compatibility_mode(true)
         azs = @availability_zones[1..-1]
         elb2 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :availability_zones => azs)
+        tests("elb source group should be amazon-elb-sg").returns(true) { elb2.source_group["GroupName"] == 'amazon-elb-sg' }
         tests("availability zones are correct").returns(azs.sort) { elb2.availability_zones.sort }
         elb2.destroy
       end

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/requests/compute/client_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:aws] | account tests', ['aws']) do
+  if Fog.mocking?
+    tests('check for vpc') do
+      tests('supports both vpc and ec2 in compatibility mode').succeeds do
+        client = Fog::Compute[:aws]
+        client.ec2_compatibility_mode(true)
+        data = Fog::Compute[:aws].describe_account_attributes.body
+        data['accountAttributeSet'].any? { |s| [*s["values"]].include?("VPC") && [*s["values"]].include?("EC2") }
+      end
+      tests('supports VPC in vpc mode').succeeds do
+        client = Fog::Compute[:aws]
+        client.ec2_compatibility_mode(true)
+        data = Fog::Compute[:aws].describe_account_attributes.body
+        data['accountAttributeSet'].any? { |s| [*s["values"]].include?("VPC") }
+      end
+
+      tests('does not support VPC and EC2 in vpc mode').succeeds do
+        client = Fog::Compute[:aws]
+        client.ec2_compatibility_mode(false)
+        data = Fog::Compute[:aws].describe_account_attributes.body
+        !data['accountAttributeSet'].any? { |s| [*s["values"]].include?("VPC") && [*s["values"]].include?("EC2") }
+      end
+    end
+  end
+end

data/tests/aws/requests/compute/route_tests.rb

@@ -0,0 +1,277 @@
+Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
+
+  @route_table_format = {
+    'routeTable' => [{
+      'routeSet'        => [{ 
+        'destinationCidrBlock'  => String,
+        'gatewayId'             => String,
+        'state'                 => String,
+      }],
+      'tagSet'          => Hash,
+      'associationSet'  => Array,
+      'routeTableId'    => String,
+      'vpcId'           => String,
+    }],
+    'requestId'   => String
+  }
+
+  @route_tables_format = {
+    'routeTableSet' => [{
+      'associationSet' => [{
+        'routeTableAssociationId' => Fog::Nullable::String,
+        'routeTableId'            => String,
+        'subnetId'                => Fog::Nullable::String,
+        'main'                    => Fog::Boolean
+      }],
+      'tagSet'         => Hash,
+      'routeSet'       => [{
+        'destinationCidrBlock' => String,
+        'gatewayId'            => Fog::Nullable::String,
+        'instanceId'           => Fog::Nullable::String,
+        'instanceOwnerId'      => Fog::Nullable::String,
+        'networkInterfaceId'   => Fog::Nullable::String,
+        'state'                => String,
+        'origin'               => String
+      }],
+      'routeTableId'   => String,
+      'vpcId'          => String,
+    }],
+    'requestId'    => String
+  }
+
+  vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+  if !Fog.mocking?
+    vpc.wait_for { state.eql? "available" }
+  end
+  @subnet_id = Fog::Compute[:aws].create_subnet(vpc.id, '10.0.10.0/24').body['subnetSet'].first['subnetId']
+  @network_interface = Fog::Compute[:aws].create_network_interface(@subnet_id, {"PrivateIpAddress" => "10.0.10.23"}).body
+  @internet_gateway_id = Fog::Compute[:aws].create_internet_gateway.body['internetGatewaySet'].first['internetGatewayId']
+  @network_interface_id = @network_interface['networkInterface']['networkInterfaceId']
+  key_name = 'fog-test-key'
+  key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
+  @cidr_block = '10.0.10.0/24'
+  @destination_cidr_block = '10.0.10.0/23'
+  @ami = 'ami-79c0ae10' # ubuntu 12.04 daily build 20120728
+
+  tests('success') do
+
+    # Test create_route_table
+    #
+    tests("#create_route_table('#{vpc.id}')").formats(@route_table_format) do
+      data = Fog::Compute[:aws].create_route_table(vpc.id).body
+      @route_table_id = data['routeTable'].first['routeTableId']
+      data
+    end
+
+    # Test associate_route_table
+    #
+    tests("#associate_route_table('#{@route_table_id}', '#{@subnet_id}')").formats({'requestId'=>String, 'associationId'=>String}) do
+      data = Fog::Compute[:aws].associate_route_table(@route_table_id, @subnet_id).body
+      @association_id = data['associationId']
+      data
+    end
+
+    # Tests create_route
+    #   - using internet gateway
+    #   - using instance id
+    #   - using network interface
+    #
+    Fog::Compute[:aws].attach_internet_gateway(@internet_gateway_id, vpc.id).body
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', '#{@internet_gateway_id}', 'nil')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil).body
+    end
+
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance.wait_for { state.eql? "running" }
+    tests("#create_route('#{@route_table_id}', '10.0.10.0/22', 'nil', '#{instance.id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/22', nil, instance.id).body
+    end
+
+    tests("#create_route('#{@route_table_id}', '10.0.10.0/21', 'nil', 'nil', '#{@network_interface_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/21', nil, nil, @network_interface_id).body
+    end
+
+    # Tests describe_route_tables
+    #   - no parameters
+    #   - filter: vpc-id => vpc_id
+    #   - filter: vpc-id => ['all']
+    #
+    tests('#describe_route_tables').formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables.body
+    end
+    tests("#describe_route_tables('vpc-id' => #{vpc.id})").formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => vpc.id).body
+    end
+    tests("#describe_route_tables('vpc-id' => ['all'])").formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => ['all']).body
+    end
+
+    # Test delete_route(route_table_id, cidr_block)
+    #
+    tests("#delete_route('#{@route_table_id}', '10.0.10.0/21')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, '10.0.10.0/21').body
+    end
+    tests("#delete_route('#{@route_table_id}', '10.0.10.0/22')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, '10.0.10.0/22').body
+    end
+
+    Fog::Compute[:aws].servers.all('instance-id'=>instance.id).first.destroy
+    if !Fog.mocking?
+      instance.wait_for { state.eql? "terminated" }
+    end
+    tests("#delete_route('#{@route_table_id}', '#{@destination_cidr_block}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block).body
+    end
+
+    # Test disassociate_route_table(association_id)
+    #
+    tests("#disassociate_route_table('#{@association_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].disassociate_route_table(@association_id).body
+    end
+
+    # Test delete_route_table(route_table_id)
+    #
+    tests("#delete_route_table('#{@route_table_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route_table(@route_table_id).body
+    end
+  end
+  tests('failure') do
+
+    @route_table_id = Fog::Compute[:aws].create_route_table(vpc.id).body['routeTable'].first['routeTableId']
+    @association_id = Fog::Compute[:aws].associate_route_table(@route_table_id, @subnet_id).body['associationId']
+    Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil)
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance.wait_for { state.eql? "running" }
+
+    # Tests create_route_table
+    #   - no parameters
+    #   - passing a nonexisting vpc
+    #
+    tests('#create_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].create_route_table
+    end
+    tests("#create_route_table('vpc-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route_table('vpc-00000000')
+    end
+
+    # Tests associate_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #   - passing a nonexisiting subnet
+    #
+    tests('#associate_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].associate_route_table
+    end
+    tests("#associate_route_table('rtb-00000000', '#{@subnet_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].associate_route_table('rtb-00000000', @subnet_id)
+    end
+    tests("#associate_route_table('#{@route_table_id}', 'subnet-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].associate_route_table(@route_table_id, 'subnet-00000000')
+    end
+
+    # Tests create_route
+    #    - no parameters
+    #    - passing a nonexisiting route table and an exisiting internet gateway
+    #    - passing a nonexisiting internet gateway
+    #    - passing a nonexisting route table and an exisiting instance
+    #    - passing a nonexisiting instance
+    #    - passing a nonexsiting route table and an exisiting network interface
+    #    - passing a nonexisiting network interface
+    #    - attempting to add a route at the same destination cidr block as another
+    #    - attempting to add a route at a less specific destination cidr block
+    #
+    tests('#create_route').raises(ArgumentError) do
+      Fog::Compute[:aws].create_route
+    end
+    tests("#create_route('rtb-00000000', '#{@destination_cidr_block}', '#{@internet_gateway_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, @internet_gateway_id)
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', 'igw-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, 'igw-00000000')
+    end
+    tests("#create_route('rtb-00000000', '#{@destination_cidr_block}', 'nil', '#{instance.id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, instance.id)
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', 'nil', 'i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, 'i-00000000')
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destinationCidrBlock}', 'nil', 'nil', 'eni-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, nil, 'eni-00000000')
+    end
+    tests("#create_route('#rtb-00000000', '#{@destination_cidr_block}', 'nil, 'nil', '#{@network_interface_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, nil, nil, @network_interface_id)
+    end
+    tests("#create_route same destination_cidr_block").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id)
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, nil, @network_interface_id).body
+    end
+    if !Fog.mocking?
+      tests("#create_route less specific destination_cidr_block").raises(Fog::Compute::AWS::Error) do
+        Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/25', @internet_gateway_id)
+       Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block).body
+      end
+    end
+
+    # Test describe_route_tables
+    #   - passing a nonexisiting vpc
+    #
+    tests("#describe_route_tables('vpc-id' => 'vpc-00000000").formats({'routeTableSet'=>Array, 'requestId'=>String}) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => 'vpc-00000000').body
+    end
+
+    # Tests delete_route
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #
+    tests('#delete_route').raises(ArgumentError) do
+      Fog::Compute[:aws].delete_route
+    end
+    tests("#delete_route('rtb-00000000', '#{@destination_cidr_block}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_route('rtb-00000000', @destination_cidr_block)
+    end
+
+    # Tests disassociate_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table association id
+    #
+    tests('#disassociate_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].disassociate_route_table
+    end
+    tests("#disassociate_route_table('rtbassoc-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].disassociate_route_table('rtbassoc-00000000')
+    end
+
+    # Tests delete_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #
+    tests('#delete_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].delete_route_table
+    end
+    tests("#delete_route_table('rtb-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_route_table('rtb-00000000')
+    end
+
+    # Dependency Tests
+    #   - route is depending on route_table, so route_table cannot be deleted
+    #
+    tests("#delete_route_table('#{@route_table_id}')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].delete_route_table(@route_table_id)
+    end
+
+    Fog::Compute[:aws].servers.all('instance-id'=>instance.id).first.destroy
+    if !Fog.mocking?
+      instance.wait_for { state.eql? "terminated" }
+    end
+    Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block)
+    Fog::Compute[:aws].disassociate_route_table(@association_id)
+    Fog::Compute[:aws].delete_route_table(@route_table_id)
+  end
+  
+  Fog::Compute[:aws].delete_network_interface(@network_interface_id)
+  Fog::Compute[:aws].detach_internet_gateway(@internet_gateway_id, vpc.id)
+  Fog::Compute[:aws].delete_internet_gateway(@internet_gateway_id)
+  Fog::Compute[:aws].delete_subnet(@subnet_id)
+  vpc.destroy
+  key.destroy
+end

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

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

data/tests/core/credential_tests.rb

@@ -63,4 +63,25 @@ Shindo.tests do
       Fog.credentials_path
     }
   end
+
+  tests('symbolize_credential?') do
+    returns(true, "username") { Fog.symbolize_credential?(:username) }
+    returns(false, "headers") { Fog.symbolize_credential?(:headers) }
+  end
+
+  tests('symbolize_credentials') do
+    h = {
+      "a" => 3,
+      :something => 2,
+      "connection_options" => {"val" => 5},
+      :headers => { 'User-Agent' => "my user agent" }
+      }
+
+      returns({
+        :a => 3,
+        :something => 2,
+        :connection_options => {:val => 5},
+        :headers => { 'User-Agent' => "my user agent" }
+        }) { Fog.symbolize_credentials h }
+  end
 end

data/tests/core/service_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Service', ['core']) do
+
+  class TestService < Fog::Service
+    recognizes :generic_user, :generic_api_key
+
+    class Real
+      attr_reader :options
+
+      def initialize(opts={})
+        @options = opts
+      end
+    end
+
+    class Mock < Real
+    end
+  end
+
+  tests('Properly passes headers') do
+    user_agent = 'Generic Fog Client'
+    params = { :generic_user => "bob", :generic_api_key => '1234', :connection_options => {:headers => { 'User-Agent' => user_agent }}}
+    service = TestService.new(params)
+
+    returns('User-Agent' => user_agent) { service.options[:connection_options][:headers] }
+  end
+
+end

data/tests/openstack/authenticate_tests.rb

@@ -134,6 +134,28 @@ Shindo.tests('OpenStack | authenticate', ['openstack']) do
 
     end
 
+    tests("legacy v1 auth") do
+      headers = {
+        "X-Storage-Url"   => "https://swift.myhost.com/v1/AUTH_tenant",
+        "X-Auth-Token"    => "AUTH_yui193bdc00c1c46c5858788yuio0e1e2p",
+        "X-Trans-Id"      => "iu99nm9999f9b999c9b999dad9cd999e99",
+        "Content-Length"  => "0",
+        "Date"            => "Wed, 07 Aug 2013 11:11:11 GMT"
+      }
+
+      Excon.stub({:method => 'GET', :path => "/auth/v1.0"},
+                 {:status => 200, :body => "", :headers => headers})
+
+      returns("https://swift.myhost.com/v1/AUTH_tenant") do
+        Fog::OpenStack.authenticate_v1(
+          :openstack_auth_uri     => URI('https://swift.myhost.com/auth/v1.0'),
+          :openstack_username     => 'tenant:dev',
+          :openstack_api_key      => 'secret_key',
+          :openstack_service_type => %w[storage])[:server_management_url]
+      end
+
+    end
+
   ensure
     Excon.stubs.clear
     Excon.defaults[:mock] = @old_mock_value

data/tests/openstack/models/storage/file_tests.rb

@@ -2,6 +2,10 @@ Shindo.tests('Fog::OpenStack::Storage | file', ['openstack']) do
 
   pending if Fog.mocking?
 
+  def object_attributes(file=@instance)
+    @instance.service.head_object(@directory.key, file.key).headers
+  end
+
   def object_meta_attributes
     @instance.service.head_object(@directory.key, @instance.key).headers.reject {|k, v| !(k =~ /X-Object-Meta-/)}
   end
@@ -67,7 +71,22 @@ Shindo.tests('Fog::OpenStack::Storage | file', ['openstack']) do
         end
 
       end
-    
+
+      tests('#content_disposition') do
+        before do
+          @instance = @directory.files.create :key => 'meta-test', :body => lorem_file, :content_disposition => 'ho-ho-ho'
+        end
+
+        after do
+          clear_metadata
+          @instance.save
+        end
+
+        tests("sets Content-Disposition on create").returns("ho-ho-ho") do
+          object_attributes(@instance)["Content-Disposition"]
+        end
+      end
+
       tests('#metadata keys') do
         
         after do

data/tests/openstack/requests/compute/flavor_tests.rb

@@ -16,37 +16,37 @@ Shindo.tests('Fog::Compute[:openstack] | flavor requests', ['openstack']) do
 
   tests('success') do
 
-    tests('#get_flavor_details(1)').formats(@flavor_format, false) do
+    tests('#get_flavor_details(1)').data_matches_schema(@flavor_format) do
       Fog::Compute[:openstack].get_flavor_details("1").body['flavor']
     end
 
-    tests('#list_flavors').formats({'flavors' => [OpenStack::Compute::Formats::SUMMARY]}) do
+    tests('#list_flavors').data_matches_schema({'flavors' => [OpenStack::Compute::Formats::SUMMARY]}) do
       Fog::Compute[:openstack].list_flavors.body
     end
 
-    tests('#list_flavors_detail').formats({'flavors' => [@flavor_format]}, false) do
+    tests('#list_flavors_detail').data_matches_schema({'flavors' => [@flavor_format]}) do
       Fog::Compute[:openstack].list_flavors_detail.body
     end
 
-    tests('#create_flavor(attributes)').formats({'flavor' => @flavor_format}) do
+    tests('#create_flavor(attributes)').data_matches_schema({'flavor' => @flavor_format}) do
       attributes = {:flavor_id => '100', :name => 'shindo test flavor', :disk => 10, :ram => 10, :vcpus => 10, :swap => "0", :rxtx_factor => 2.4, :ephemeral => 0, :is_public => false}
       Fog::Compute[:openstack].create_flavor(attributes).body
     end
 
-    tests('delete_flavor(flavor_id)').succeeds do
-      Fog::Compute[:openstack].delete_flavor('100')
+    tests('add_flavor_access(flavor_ref, tenant_id)').data_matches_schema({'flavor_access' => [{'tenant_id' => String, 'flavor_id' => String}]}) do
+      Fog::Compute[:openstack].add_flavor_access(100, 1).body
     end
 
-    tests('add_flavor_access(flavor_ref, tenant_id)').formats({'flavor_access' => [{'tenant_id' => 1, 'flavor_id' => 1}]}) do
-      Fog::Compute[:openstack].add_flavor_access(1, 1).body
+    tests('remove_flavor_access(flavor_ref, tenant_id)').data_matches_schema({'flavor_access' => []}) do
+      Fog::Compute[:openstack].remove_flavor_access(100, 1).body
     end
 
-    tests('remove_flavor_access(flavor_ref, tenant_id)').formats({'flavor_access' => []}) do
-      Fog::Compute[:openstack].remove_flavor_access(1, 1).body
+    tests('list_tenants_with_flavor_access(flavor_ref)').data_matches_schema({'flavor_access' => [{'tenant_id' => String, 'flavor_id' => String}]}) do
+      Fog::Compute[:openstack].list_tenants_with_flavor_access(100).body
     end
 
-    tests('list_tenants_with_flavor_access(flavor_ref)').formats({'flavor_access' => [{'tenant_id' => nil, 'flavor_id' => 1}]}) do
-      Fog::Compute[:openstack].list_tenants_with_flavor_access(1).body
+    tests('delete_flavor(flavor_id)').succeeds do
+      Fog::Compute[:openstack].delete_flavor('100')
     end
 
   end
@@ -57,6 +57,21 @@ Shindo.tests('Fog::Compute[:openstack] | flavor requests', ['openstack']) do
       Fog::Compute[:openstack].get_flavor_details("0")
     end
 
+    tests('add_flavor_access(1234, 1)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].add_flavor_access(1234, 1).body
+    end
+
+    tests('remove_flavor_access(1234, 1)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].remove_flavor_access(1234, 1).body
+    end
+
+    tests('list_tenants_with_flavor_access(1234)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].list_tenants_with_flavor_access(1234)
+    end
+
   end
 
 end