fog 1.7.0 → 1.8.0

data/tests/aws/models/iam/users_tests.rb

@@ -4,12 +4,16 @@ Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
   @iam = Fog::AWS[:iam]
   @user_one_name = 'fake_user_one'
   @user_two_name = 'fake_user_two'
-  
+
+  @user_three_name = 'fake_user_three'
+  @user_three_path = '/path/to/fake_user_three/'
+  @user_four_name = 'fake_user_four'
+
   tests('#create').succeeds do
     @user_one = @iam.users.create(:id => @user_one_name)
     @user_one.id == @user_one_name
   end
-  
+
   tests('#all','there is only one user').succeeds do
     @iam.users.size == 1
   end
@@ -43,6 +47,16 @@ Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
     @iam.users.get(@user_one_name).access_keys.empty?
   end
   
+  tests('#create', 'assigns path').succeeds do
+    @user_three = @iam.users.create(:id => @user_three_name, :path => @user_three_path)
+    @user_three.path == @user_three_path
+  end
+
+  tests('#create', 'defaults path to /').succeeds do
+    @user_four = @iam.users.create(:id => @user_four_name)
+    @user_four.path == '/'
+  end
+
   tests('#destroy','an existing user').succeeds do
     @iam.users.get(@user_one_name).destroy
   end

data/tests/aws/requests/auto_scaling/notification_configuration_tests.rb

@@ -3,6 +3,7 @@ Shindo.tests('AWS::AutoScaling | notification configuration requests', ['aws', '
   image_id = {  # Ubuntu 12.04 LTS 64-bit EBS
     'ap-northeast-1' => 'ami-60c77761',
     'ap-southeast-1' => 'ami-a4ca8df6',
+    'ap-southeast-2' => 'ami-fb8611c1',
     'eu-west-1'      => 'ami-e1e8d395',
     'sa-east-1'      => 'ami-8cd80691',
     'us-east-1'      => 'ami-a29943cb',

data/tests/aws/requests/auto_scaling/tag_tests.rb

@@ -3,6 +3,7 @@ Shindo.tests('AWS::AutoScaling | tag requests', ['aws', 'auto_scaling']) do
   image_id = {  # Ubuntu 12.04 LTS 64-bit EBS
     'ap-northeast-1' => 'ami-60c77761',
     'ap-southeast-1' => 'ami-a4ca8df6',
+    'ap-southeast-2' => 'ami-fb8611c1',
     'eu-west-1'      => 'ami-e1e8d395',
     'sa-east-1'      => 'ami-8cd80691',
     'us-east-1'      => 'ami-a29943cb',

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

@@ -92,6 +92,7 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
       'availabilityZone'                => String,
       'duration'                        => Integer,
       'fixedPrice'                      => Float,
+      'offeringType'                    => String,
       'usagePrice'                      => Float,
       'productDescription'              => String,
       'instanceTenancy'                 => String,
@@ -115,6 +116,7 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
       'fixedPrice'          => Float,
       'usagePrice'          => Float,
       'instanceCount'       => Integer,
+      'offeringType'        => String,
       'productDescription'  => String,
       'state'               => String,
       'tagSet'              => [{

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

@@ -136,6 +136,10 @@ Shindo.tests('Fog::Compute[:aws] | volume requests', ['aws']) do
 
     Fog::Compute[:aws].volumes.get(@volume_id).wait_for { ready? }
 
+    tests("#modify_volume_attribute('#{@volume_id}', true)").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].modify_volume_attribute(@volume_id, true).body
+    end
+
     tests("#delete_volume('#{@volume_id}')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].delete_volume(@volume_id).body
     end
@@ -156,6 +160,10 @@ Shindo.tests('Fog::Compute[:aws] | volume requests', ['aws']) do
       Fog::Compute[:aws].detach_volume('vol-00000000')
     end
 
+    tests("#modify_volume_attribute('vol-00000000', true)").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].modify_volume_attribute('vol-00000000', true)
+    end
+
     tests("#detach_volume('#{@volume.identity}')").raises(Fog::Compute::AWS::Error) do
       Fog::Compute[:aws].detach_volume(@volume.identity)
     end

data/tests/aws/requests/storage/object_tests.rb

@@ -4,6 +4,14 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
 
   tests('success') do
 
+    @multiple_delete_format = {
+      'DeleteResult' => [{
+        'Deleted' => {
+          'Key' => String
+        }
+      }]
+    }
+
     tests("#put_object('#{@directory.identity}', 'fog_object', lorem_file)").succeeds do
       Fog::Storage[:aws].put_object(@directory.identity, 'fog_object', lorem_file)
     end
@@ -91,12 +99,16 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
     tests("#delete_object('#{@directory.identity}', 'fog_object')").succeeds do
       Fog::Storage[:aws].delete_object(@directory.identity, 'fog_object')
     end
-    
+
     tests("#get_object_http_url('#{@directory.identity}', 'fog_object', expiration timestamp)").returns(true) do
       object_url = Fog::Storage[:aws].get_object_http_url(@directory.identity, 'fog_object', (Time.now + 60))
       (object_url =~ /http:\/\/#{Regexp.quote(@directory.identity)}\.s3\.amazonaws\.com\/fog_object/) != nil
     end
 
+    tests("delete_multiple_objects('#{@directory.identity}', ['fog_object', 'fog_other_object'])").formats(@multiple_delete_format) do
+      Fog::Storage[:aws].delete_multiple_objects(@directory.identity, ['fog_object', 'fog_other_object']).body
+    end
+
   end
 
   tests('failure') do
@@ -137,6 +149,11 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
       Fog::Storage[:aws].delete_object('fognonbucket', 'fog_non_object')
     end
 
+    tests("#delete_multiple_objects('fognonbucket', ['fog_non_object'])").raises(Excon::Errors::NotFound) do
+      pending if Fog.mocking?
+      Fog::Storage[:aws].delete_multiple_objects('fognonbucket', ['fog_non_object'])
+    end
+
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', 'invalid')").raises(Excon::Errors::BadRequest) do
       Fog::Storage[:aws].put_object_acl('#{@directory.identity}', 'fog_object', 'invalid')
     end

data/tests/aws/requests/storage/versioning_tests.rb

@@ -134,6 +134,75 @@ Shindo.tests('Fog::Storage[:aws] | versioning', ["aws"]) do
       end
     end
 
+    tests("deleting_multiple_objects('#{@aws_bucket_name}", 'file') do
+      clear_bucket
+
+      bucket = Fog::Storage[:aws].directories.get(@aws_bucket_name)
+
+      file_count = 5
+      file_names = []
+      files = {}
+      file_count.times do |id|
+        file_names << "file_#{id}"
+        files[file_names.last] = bucket.files.create(:body => 'a',
+                                                     :key => file_names.last)
+      end
+
+      tests("deleting an object just stores a delete marker").returns(true) do
+        Fog::Storage[:aws].delete_multiple_objects(@aws_bucket_name,
+                                                   file_names)
+        versions = Fog::Storage[:aws].get_bucket_object_versions(
+                      @aws_bucket_name)
+        all_versions = {}
+        versions.body['Versions'].each do |version|
+          object = version[version.keys.first]
+          next if file_names.index(object['Key']).nil?
+          if !all_versions.has_key?(object['Key'])
+            all_versions[object['Key']] = version.has_key?('DeleteMarker')
+          else
+            all_versions[object['Key']] |= version.has_key?('DeleteMarker')
+          end
+        end
+        all_true = true
+        all_versions.values.each do |marker|
+          all_true = false if !marker
+        end
+        all_true
+      end
+
+      tests("there are two versions: the original and the delete marker").
+          returns(file_count*2) do
+        versions = Fog::Storage[:aws].get_bucket_object_versions(
+                      @aws_bucket_name)
+        versions.body['Versions'].size
+      end
+
+      tests("deleting the delete marker makes the object available again").
+          returns(true) do
+        versions = Fog::Storage[:aws].get_bucket_object_versions(
+                      @aws_bucket_name)
+        delete_markers = []
+        file_versions = {}
+        versions.body['Versions'].each do |version|
+          object = version[version.keys.first]
+          next if object['VersionId'] == files[object['Key']].version
+          file_versions[object['Key']] = object['VersionId']
+        end
+
+        Fog::Storage[:aws].delete_multiple_objects(@aws_bucket_name,
+                                                   file_names,
+                                                   'versionId' => file_versions)
+        all_true = true
+        file_names.each do |file|
+          res = Fog::Storage[:aws].get_object(@aws_bucket_name, file)
+          all_true = false if res.headers['x-amz-version-id'] !=
+                              files[file].version
+        end
+        all_true
+      end
+
+    end
+
     tests("get_bucket('#{@aws_bucket_name}'") do
       clear_bucket
 
@@ -181,6 +250,7 @@ Shindo.tests('Fog::Storage[:aws] | versioning', ["aws"]) do
     tests("#delete_object('#{@aws_bucket_name}', '#{file.key}', 'versionId' => 'bad_version'").raises(Excon::Errors::BadRequest) do
       Fog::Storage[:aws].delete_object(@aws_bucket_name, file.key, 'versionId' => '-1')
     end
+
   end
 
   # don't keep the bucket around

data/tests/brightbox/compute_tests.rb

@@ -1,9 +1,101 @@
-Shindo.tests('Fog::Compute::Brightbox::Real', ['brightbox']) do
+Shindo.tests('Fog::Compute[:brightbox]', ['brightbox']) do
 
-  @bb = Fog::Compute::Brightbox::Real.new({})
+  @test_service = Fog::Compute[:brightbox]
 
   tests("#respond_to? :default_image").returns(true) do
-    @bb.respond_to?(:default_image)
+    @test_service.respond_to?(:default_image)
   end
 
-end
+end
+
+Shindo.tests('Fog::Compute.new', ['brightbox']) do
+
+  tests("service options") do
+    {
+      :brightbox_api_url => "https://example.com",
+      :brightbox_auth_url => "https://example.com",
+      :brightbox_client_id => "app-12345",
+      :brightbox_secret => "12345abdef6789",
+      :brightbox_username => "user-12345",
+      :brightbox_password => "password1234",
+      :brightbox_account => "acc-12345",
+      :brightbox_access_token => "12345abdef6789",
+      :brightbox_refresh_token => "12345abdef6789",
+      :brightbox_token_management => false
+    }.each_pair do |option, sample|
+      tests("recognises :#{option}").returns(true) do
+        options = {:provider => "Brightbox"}
+        options[option] = sample
+        begin
+          Fog::Compute.new(options)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+    end
+  end
+
+  tests("automatic token management") do
+    service_options = {:provider => "Brightbox"}
+
+    tests("when enabled (default)") do
+      service_options[:brightbox_token_management] = true
+
+      tests("using bad token") do
+        service_options[:brightbox_access_token] = "bad-token"
+
+        tests("#request").returns(true, "returns a Hash") do
+          pending if Fog.mocking?
+          service = Fog::Compute.new(service_options)
+          response = service.get_authenticated_user
+          response.is_a?(Hash) # This is an outstanding issue, should be Excon::Response
+        end
+      end
+    end
+
+    tests("when disabled") do
+      service_options[:brightbox_token_management] = false
+
+      tests("using bad token") do
+        service_options[:brightbox_access_token] = "bad-token"
+
+        tests("#request").raises(Excon::Errors::Unauthorized) do
+          pending if Fog.mocking?
+          service = Fog::Compute.new(service_options)
+          service.get_authenticated_user
+        end
+      end
+    end
+  end
+
+  tests("account scoping") do
+    service = Fog::Compute.new(:provider => "Brightbox")
+    configured_account = Fog.credentials[:brightbox_account]
+    tests("when Fog.credentials are #{configured_account}") do
+      test("#scoped_account == #{configured_account}") { service.scoped_account == configured_account }
+    end
+
+    set_account = "acc-35791"
+    tests("when Compute instance is updated to #{set_account}") do
+      service.scoped_account = set_account
+      test("#scoped_account == #{set_account}") { service.scoped_account == set_account }
+    end
+
+    tests("when Compute instance is reset") do
+      service.scoped_account_reset
+      test("#scoped_account == #{configured_account}") { service.scoped_account == configured_account }
+    end
+
+    optioned_account = "acc-56789"
+    tests("when Compute instance created with :brightbox_account => #{optioned_account}") do
+      service = Fog::Compute.new(:provider => "Brightbox", :brightbox_account => optioned_account )
+      test("#scoped_account == #{optioned_account}") { service.scoped_account == optioned_account }
+    end
+
+    request_account = "acc-24680"
+    tests("when requested with #{request_account}") do
+      test("#scoped_account(#{request_account}) == #{request_account}") { service.scoped_account(request_account) == request_account }
+    end
+  end
+end

data/tests/brightbox/models/compute/account_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("Fog::Compute[:brightbox] | Account model", ["brightbox"]) do
+
+  @account = Fog::Compute[:brightbox].account
+
+  tests("success") do
+
+    tests("#reset_ftp_password") do
+      pending if Fog.mocking?
+      test("original ftp password is blanked") { @account.library_ftp_password.nil? }
+      @new_password = @account.reset_ftp_password
+      test("new ftp password was not nil") { !@new_password.nil? }
+      test("new ftp password is set") { @account.library_ftp_password == @new_password }
+    end
+  end
+end

data/tests/brightbox/oauth2_tests.rb

@@ -0,0 +1,103 @@
+Shindo.tests("Fog::Brightbox::OAuth2", ["brightbox"]) do
+
+  tests("CredentialSet") do
+    @client_id     = "app-12345"
+    @client_secret = "__mashed_keys_123__"
+    @username      = "usr-12345"
+    @password      = "__mushed_keys_321__"
+    @access_token  = "12efde32fdfe4989"
+    @refresh_token = "7894389f9074f071"
+
+    tests("with client credentials") do
+      credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret)
+      tests("#user_details?").returns(false) { credentials.user_details? }
+      tests("#access_token?").returns(false) { credentials.access_token? }
+      tests("#refresh_token?").returns(false) { credentials.refresh_token? }
+      tests("#best_grant_strategy").returns(true) do
+        credentials.best_grant_strategy.is_a?(Fog::Brightbox::OAuth2::ClientCredentialsStrategy)
+      end
+    end
+
+    tests("with user credentials") do
+      options = {:username => @username, :password => @password}
+      credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret, options)
+      tests("#user_details?").returns(true) { credentials.user_details? }
+      tests("#access_token?").returns(false) { credentials.access_token? }
+      tests("#refresh_token?").returns(false) { credentials.refresh_token? }
+      tests("#best_grant_strategy").returns(true) do
+        credentials.best_grant_strategy.is_a?(Fog::Brightbox::OAuth2::UserCredentialsStrategy)
+      end
+    end
+
+    tests("with existing tokens") do
+      options = {:username => @username, :access_token => @access_token, :refresh_token => @refresh_token}
+      credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret, options)
+      tests("#user_details?").returns(false) { credentials.user_details? }
+      tests("#access_token?").returns(true) { credentials.access_token? }
+      tests("#refresh_token?").returns(true) { credentials.refresh_token? }
+      tests("#best_grant_strategy").returns(true) do
+        credentials.best_grant_strategy.is_a?(Fog::Brightbox::OAuth2::RefreshTokenStrategy)
+      end
+    end
+  end
+
+  tests("GrantTypeStrategy") do
+    credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret)
+    strategy = Fog::Brightbox::OAuth2::GrantTypeStrategy.new(credentials)
+
+    tests("#respond_to? :authorization_body_data").returns(true) do
+      strategy.respond_to?(:authorization_body_data)
+    end
+  end
+
+  tests("ClientCredentialsStrategy") do
+    credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret)
+    strategy = Fog::Brightbox::OAuth2::ClientCredentialsStrategy.new(credentials)
+
+    tests("#respond_to? :authorization_body_data").returns(true) do
+      strategy.respond_to?(:authorization_body_data)
+    end
+
+    tests("#authorization_body_data") do
+      authorization_body_data = strategy.authorization_body_data
+      test("grant_type == none") { authorization_body_data["grant_type"] == "none" }
+      test("client_id == #{@client_id}") { authorization_body_data["client_id"] == @client_id }
+    end
+  end
+
+  tests("UserCredentialsStrategy") do
+    options = {:username => @username, :password => @password}
+    credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret, options)
+    strategy = Fog::Brightbox::OAuth2::UserCredentialsStrategy.new(credentials)
+
+    tests("#respond_to? :authorization_body_data").returns(true) do
+      strategy.respond_to?(:authorization_body_data)
+    end
+
+    tests("#authorization_body_data") do
+      authorization_body_data = strategy.authorization_body_data
+      test("grant_type == password") { authorization_body_data["grant_type"] == "password" }
+      test("client_id == #{@client_id}") { authorization_body_data["client_id"] == @client_id }
+      test("username == #{@username}") { authorization_body_data["username"] == @username }
+      test("password == #{@password}") { authorization_body_data["password"] == @password }
+    end
+  end
+
+  tests("RefreshTokenStrategy") do
+    refresh_token = "ab4b39dddf909"
+    options = {:refresh_token => refresh_token}
+    credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret, options)
+    strategy = Fog::Brightbox::OAuth2::RefreshTokenStrategy.new(credentials)
+
+    tests("#respond_to? :authorization_body_data").returns(true) do
+      strategy.respond_to?(:authorization_body_data)
+    end
+
+    tests("#authorization_body_data") do
+      authorization_body_data = strategy.authorization_body_data
+      test("grant_type == refresh_token") { authorization_body_data["grant_type"] == "refresh_token" }
+      test("client_id == #{@client_id}") { authorization_body_data["client_id"] == @client_id }
+      test("refresh_token == #{refresh_token}") { authorization_body_data["refresh_token"] == refresh_token }
+    end
+  end
+end

data/tests/brightbox/requests/compute/account_tests.rb

@@ -36,9 +36,16 @@ Shindo.tests('Fog::Compute[:brightbox] | account requests', ['brightbox']) do
       formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
     end
 
-    tests("#reset_ftp_password_account") do
+    tests("#reset_ftp_password_scoped_account") do
       pending if Fog.mocking?
-      result = Fog::Compute[:brightbox].reset_ftp_password_account
+      result = Fog::Compute[:brightbox].reset_ftp_password_scoped_account
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
+      test("new ftp password is visible") { ! result["library_ftp_password"].nil?  }
+    end
+
+    tests("#reset_ftp_password_account(#{@scoped_account_identifier})") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].reset_ftp_password_account(@scoped_account_identifier)
       formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
       test("new ftp password is visible") { ! result["library_ftp_password"].nil?  }
     end