fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

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

@@ -0,0 +1,108 @@
+require 'fog/aws/requests/storage/cors_utils'
+
+Shindo.tests('Fog::Storage::AWS | CORS utils', ["aws"]) do
+  tests(".hash_to_cors") do
+    tests(".hash_to_cors({}) at xpath //CORSConfiguration").returns("", "has an empty CORSConfiguration") do
+      xml = Fog::Storage::AWS.hash_to_cors({})
+      Nokogiri::XML(xml).xpath("//CORSConfiguration").first.content.chomp
+    end
+
+    tests(".hash_to_cors({}) at xpath //CORSConfiguration/CORSRule").returns(nil, "has no CORSRules") do
+      xml = Fog::Storage::AWS.hash_to_cors({})
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule").first
+    end
+
+    cors = {
+      'CORSConfiguration' => [
+        {
+          'AllowedOrigin' => ['origin_123', 'origin_456'],
+          'AllowedMethod' => ['GET', 'POST'],
+          'AllowedHeader' => ['Accept', 'Content-Type'],
+          'ID' => 'blah-888',
+          'MaxAgeSeconds' => 2500,
+          'ExposeHeader' => ['x-some-header', 'x-other-header']
+        }
+      ]
+    }
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedOrigin").returns("origin_123", "returns the CORSRule AllowedOrigin") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedOrigin")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedOrigin").returns("origin_456", "returns the CORSRule AllowedOrigin") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedOrigin")[1].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedMethod").returns("GET", "returns the CORSRule AllowedMethod") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedMethod")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedMethod").returns("POST", "returns the CORSRule AllowedMethod") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedMethod")[1].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedHeader").returns("Accept", "returns the CORSRule AllowedHeader") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedHeader")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/AllowedHeader").returns("Content-Type", "returns the CORSRule AllowedHeader") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/AllowedHeader")[1].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/ID").returns("blah-888", "returns the CORSRule ID") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/ID")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/MaxAgeSeconds").returns("2500", "returns the CORSRule MaxAgeSeconds") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/MaxAgeSeconds")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/ExposeHeader").returns("x-some-header", "returns the CORSRule ExposeHeader") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/ExposeHeader")[0].content
+    end
+
+    tests(".hash_to_cors(#{cors.inspect}) at xpath //CORSConfiguration/CORSRule/ExposeHeader").returns("x-other-header", "returns the CORSRule ExposeHeader") do
+      xml = Fog::Storage::AWS.hash_to_cors(cors)
+      Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/ExposeHeader")[1].content
+    end
+  end
+
+  tests(".cors_to_hash") do
+    cors_xml = <<-XML
+<CORSConfiguration>
+  <CORSRule>
+    <AllowedOrigin>http://www.example.com</AllowedOrigin>
+    <AllowedOrigin>http://www.example2.com</AllowedOrigin>
+    <AllowedHeader>Content-Length</AllowedHeader>
+    <AllowedHeader>X-Foobar</AllowedHeader>
+    <AllowedMethod>PUT</AllowedMethod>
+    <AllowedMethod>GET</AllowedMethod>
+    <MaxAgeSeconds>3000</MaxAgeSeconds>
+    <ExposeHeader>x-amz-server-side-encryption</ExposeHeader>
+    <ExposeHeader>x-amz-balls</ExposeHeader>
+  </CORSRule>
+</CORSConfiguration>
+XML
+
+    tests(".cors_to_hash(#{cors_xml.inspect})").returns({
+      "CORSConfiguration" => [{
+        "AllowedOrigin" => ["http://www.example.com", "http://www.example2.com"],
+        "AllowedHeader" => ["Content-Length", "X-Foobar"],
+        "AllowedMethod" => ["PUT", "GET"],
+        "MaxAgeSeconds" => 3000,
+        "ExposeHeader" => ["x-amz-server-side-encryption", "x-amz-balls"]
+      }]
+    }, 'returns hash of CORS XML') do
+      Fog::Storage::AWS.cors_to_hash(cors_xml)
+    end
+  end
+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,17 @@
+Shindo.tests("Fog::Compute[:brightbox] | Account model", ["brightbox"]) do
+
+  pending if Fog.mocking?
+
+  @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/models/compute/server_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests("Fog::Compute[:brightbox] | Server model", ["brightbox"]) do
+
+  pending if Fog.mocking?
+
+  tests("success") do
+
+    unless Fog.mocking?
+      @server = Brightbox::Compute::TestSupport.get_test_server
+      server_id = @server.id
+    end
+
+    tests("#dns_name") do
+      pending if Fog.mocking?
+      returns("public.#{@server.fqdn}") { @server.dns_name }
+    end
+
+    unless Fog.mocking?
+      @server.destroy
+    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