fog-aws 3.0.0 → 3.10.0

data/tests/requests/efs/helper.rb

@@ -10,6 +10,8 @@ class AWS
         "NumberOfMountTargets" => Integer,
         "OwnerId"              => String,
         "PerformanceMode"      => String,
+        "Encrypted"            => Fog::Nullable::Boolean,
+        "KmsKeyId"             => Fog::Nullable::String,
         "SizeInBytes"          => {
           "Timestamp" => Fog::Nullable::Float,
           "Value"     => Integer

data/tests/requests/elbv2/helper.rb

@@ -0,0 +1,66 @@
+class AWS
+  module ELBV2
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      LOAD_BALANCER = {
+        "AvailabilityZones" => [{
+          "SubnetId" => String, "ZoneName" => String,
+          "LoadBalancerAddresses" => [Fog::Nullable::Hash]
+        }],
+        "LoadBalancerArn" => String,
+        "DNSName" => String,
+        "CreatedTime" => Time,
+        "LoadBalancerName" => String,
+        "VpcId" => String,
+        "CanonicalHostedZoneId" => String,
+        "Scheme" => String,
+        "Type" => String,
+        "State" => {"Code" => String},
+        "SecurityGroups" => [Fog::Nullable::String]
+      }
+
+      DESCRIBE_LOAD_BALANCERS = BASIC.merge({
+        'DescribeLoadBalancersResult' => {'LoadBalancers' => [LOAD_BALANCER], 'NextMarker' => Fog::Nullable::String}
+      })
+
+      CREATE_LOAD_BALANCER = BASIC.merge({
+        'CreateLoadBalancerResult' => {'LoadBalancers' => [LOAD_BALANCER]}
+      })
+
+      LISTENER_DEFAULT_ACTIONS = [{
+        "Type" => String,
+        "Order" => String,
+        "TargetGroupArn" => String,
+        "RedirectConfig" => Fog::Nullable::Hash,
+        "ForwardConfig" => Fog::Nullable::Hash,
+        "FixedResponseConfig" => Fog::Nullable::Hash
+      }]
+
+      LISTENER = {
+        "LoadBalancerArn" => String,
+        "Protocol" => String,
+        "Port" => String,
+        "ListenerArn" => String,
+        "SslPolicy" => String,
+        "DefaultActions" => LISTENER_DEFAULT_ACTIONS,
+        "Certificates" => [{"CertificateArn" => String}]
+      }
+
+      DESCRIBE_LISTENERS = BASIC.merge({
+        'DescribeListenersResult' => {'Listeners' => [LISTENER], 'NextMarker' => Fog::Nullable::String}
+      })
+
+      TAG_DESCRIPTIONS = [{
+        "Tags" => Hash,
+        "ResourceArn" => String
+      }]
+
+      DESCRIBE_TAGS = BASIC.merge({
+        'DescribeTagsResult' => {'TagDescriptions' => TAG_DESCRIPTIONS}
+      })
+    end
+  end
+end

data/tests/requests/elbv2/load_balancer_tests.rb

@@ -0,0 +1,50 @@
+Shindo.tests('AWS::ELBV2 | load_balancer_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-elb'
+  @key_name = 'fog-test'
+  vpc = Fog::Compute[:aws].create_vpc('10.255.254.64/28').body['vpcSet'].first
+  @subnet_id = Fog::Compute[:aws].create_subnet(vpc['vpcId'], vpc['cidrBlock']).body['subnet']['subnetId']
+  @tags = { 'test1' => 'Value1', 'test2' => 'Value2' }
+
+  tests('success') do
+    tests('#create_load_balancer').formats(AWS::ELBV2::Formats::CREATE_LOAD_BALANCER) do
+      options = {
+        subnets: [@subnet_id]
+      }
+      load_balancer = Fog::AWS[:elbv2].create_load_balancer(@load_balancer_id, options).body
+      @load_balancer_arn = load_balancer['CreateLoadBalancerResult']['LoadBalancers'].first['LoadBalancerArn']
+      load_balancer
+    end
+
+    tests('#describe_load_balancers').formats(AWS::ELBV2::Formats::DESCRIBE_LOAD_BALANCERS) do
+      Fog::AWS[:elbv2].describe_load_balancers.body
+    end
+
+    tests('#describe_load_balancers with bad name') do
+      raises(Fog::AWS::ELBV2::NotFound) { Fog::AWS[:elbv2].describe_load_balancers('LoadBalancerNames' => 'none-such-lb') }
+    end
+
+    tests("#add_tags('#{@load_balancer_arn}', #{@tags})").formats(AWS::ELBV2::Formats::BASIC) do
+      Fog::AWS[:elbv2].add_tags(@load_balancer_arn, @tags).body
+    end
+
+    tests('#describe_tags').formats(AWS::ELBV2::Formats::DESCRIBE_TAGS) do
+      Fog::AWS[:elbv2].describe_tags(@load_balancer_arn).body
+    end
+
+    tests('#describe_tags with at least one wrong arn') do
+      raises(Fog::AWS::ELBV2::NotFound) { Fog::AWS[:elbv2].describe_tags([@load_balancer_arn, 'wrong_arn']) }
+    end
+
+    tests("#describe_tags(#{@load_balancer_arn})").returns(@tags) do
+     Fog::AWS[:elbv2].describe_tags(@load_balancer_arn).body['DescribeTagsResult']['TagDescriptions'].first['Tags']
+    end
+
+    tests("#remove_tags('#{@load_balancer_arn}', #{@tags.keys})").formats(AWS::ELBV2::Formats::BASIC) do
+      Fog::AWS[:elbv2].remove_tags(@load_balancer_arn, @tags.keys).body
+    end
+
+    tests("#describe_tags(#{@load_balancer_arn})").returns({}) do
+      Fog::AWS[:elbv2].describe_tags(@load_balancer_arn).body['DescribeTagsResult']['TagDescriptions'].first['Tags']
+    end
+  end
+end

data/tests/requests/glacier/tree_hash_tests.rb

@@ -59,4 +59,33 @@ Shindo.tests('AWS::Glacier | glacier tree hash calcuation', ['aws']) do
 
   end
 
+  # Aligned is used in general sense of https://en.wikipedia.org/wiki/Data_structure_alignment
+  # except we are not dealing with data in memory, but with parts in "virtual" space of whole file.
+  # Tests for https://github.com/fog/fog-aws/issues/520 and https://github.com/fog/fog-aws/issues/521
+  tests('multipart with unaligned parts') do
+    tree_hash = Fog::AWS::Glacier::TreeHash.new
+    part = ('x' * 512*1024)
+    returns(Fog::AWS::Glacier::TreeHash.digest(part)) { tree_hash.add_part part }
+
+    # At this point, we have 0.5MB in tree_hash. That means that the next part we add will not be aligned,
+    # because it will start on 0.5MB which is not 1MB boundary.
+    part2 = ('x' * 512*1024) + ('y'*1024*1024) + ('z'* 512*1024)
+    returns(Fog::AWS::Glacier::TreeHash.digest(part + part2)) { tree_hash.add_part part2 ; tree_hash.hexdigest }
+
+    # Here we are adding another 1.5MB to tree_hash which has size of 3.5MB. Again, 3.5MB is not on 1MB boundary,
+    # so this is another unaligned part. It does test different part of code, though.
+    tree_hash.add_part('z'* 512*1024 + 't'*1024*1024)
+
+    expected = OpenSSL::Digest::SHA256.hexdigest(
+                 OpenSSL::Digest::SHA256.digest(
+                    OpenSSL::Digest::SHA256.digest('x' * 1024*1024) + OpenSSL::Digest::SHA256.digest('y' * 1024*1024)
+                 ) +
+                 OpenSSL::Digest::SHA256.digest(
+                   OpenSSL::Digest::SHA256.digest('z' * 1024*1024) + OpenSSL::Digest::SHA256.digest('t' * 1024*1024)
+                 )
+               )
+    returns(expected) { tree_hash.hexdigest}
+
+  end
+
 end

data/tests/requests/storage/acl_utils_tests.rb

@@ -1,44 +1,44 @@
 require 'fog/aws/requests/storage/acl_utils'
 
-Shindo.tests('Fog::Storage::AWS | ACL utils', ["aws"]) do
+Shindo.tests('Fog::AWS::Storage | ACL utils', ["aws"]) do
   tests(".hash_to_acl") do
     tests(".hash_to_acl({}) at xpath //AccessControlPolicy").returns("", "has an empty AccessControlPolicy") do
-      xml = Fog::Storage::AWS.hash_to_acl({})
+      xml = Fog::AWS::Storage.hash_to_acl({})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy").first.content.chomp
     end
 
     tests(".hash_to_acl({}) at xpath //AccessControlPolicy/Owner").returns(nil, "does not have an Owner element") do
-      xml = Fog::Storage::AWS.hash_to_acl({})
+      xml = Fog::AWS::Storage.hash_to_acl({})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner").first
     end
 
     tests(".hash_to_acl('Owner' => {}) at xpath //AccessControlPolicy/Owner").returns(nil, "does not have an Owner element") do
-      xml = Fog::Storage::AWS.hash_to_acl('Owner' => {})
+      xml = Fog::AWS::Storage.hash_to_acl('Owner' => {})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner").first
     end
 
     tests(".hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'}) at xpath //AccessControlPolicy/Owner/ID").returns("abcdef0123456789", "returns the Owner ID") do
-      xml = Fog::Storage::AWS.hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'})
+      xml = Fog::AWS::Storage.hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner/ID").first.content
     end
 
     tests(".hash_to_acl('Owner' => {'DisplayName' => 'bob'}) at xpath //AccessControlPolicy/Owner/ID").returns(nil, "does not have an Owner ID element") do
-      xml = Fog::Storage::AWS.hash_to_acl('Owner' => {'DisplayName' => 'bob'})
+      xml = Fog::AWS::Storage.hash_to_acl('Owner' => {'DisplayName' => 'bob'})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner/ID").first
     end
 
     tests(".hash_to_acl('Owner' => {'DisplayName' => 'bob'}) at xpath //AccessControlPolicy/Owner/DisplayName").returns("bob", "returns the Owner DisplayName") do
-      xml = Fog::Storage::AWS.hash_to_acl('Owner' => {'DisplayName' => 'bob'})
+      xml = Fog::AWS::Storage.hash_to_acl('Owner' => {'DisplayName' => 'bob'})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner/DisplayName").first.content
     end
 
     tests(".hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'}) at xpath //AccessControlPolicy/Owner/DisplayName").returns(nil, "does not have an Owner DisplayName element") do
-      xml = Fog::Storage::AWS.hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'})
+      xml = Fog::AWS::Storage.hash_to_acl('Owner' => {'ID' => 'abcdef0123456789'})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/Owner/DisplayName").first
     end
 
     tests(".hash_to_acl({}) at xpath //AccessControlPolicy/AccessControlList").returns(nil, "has no AccessControlList") do
-      xml = Fog::Storage::AWS.hash_to_acl({})
+      xml = Fog::AWS::Storage.hash_to_acl({})
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlPolicy").first
     end
 
@@ -55,22 +55,22 @@ Shindo.tests('Fog::Storage::AWS | ACL utils', ["aws"]) do
     }
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee").returns("CanonicalUser", "has an xsi:type of CanonicalUser") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee").first.attributes["type"].value
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/ID").returns("abcdef0123456789", "returns the Grantee ID") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/ID").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/DisplayName").returns("bob", "returns the Grantee DisplayName") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/DisplayName").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Permission").returns("READ", "returns the Grantee Permission") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Permission").first.content
     end
 
@@ -86,17 +86,17 @@ Shindo.tests('Fog::Storage::AWS | ACL utils', ["aws"]) do
     }
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee").returns("AmazonCustomerByEmail", "has an xsi:type of AmazonCustomerByEmail") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee").first.attributes["type"].value
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/EmailAddress").returns("user@example.com", "returns the Grantee EmailAddress") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/EmailAddress").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Permission").returns("FULL_CONTROL", "returns the Grantee Permission") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Permission").first.content
     end
 
@@ -112,17 +112,17 @@ Shindo.tests('Fog::Storage::AWS | ACL utils', ["aws"]) do
     }
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee").returns("Group", "has an xsi:type of Group") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee").first.attributes["type"].value
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/URI").returns("http://acs.amazonaws.com/groups/global/AllUsers", "returns the Grantee URI") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/URI").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Permission").returns("WRITE", "returns the Grantee Permission") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Permission").first.content
     end
 
@@ -151,22 +151,22 @@ Shindo.tests('Fog::Storage::AWS | ACL utils', ["aws"]) do
     }
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant").returns(3, "has three elements") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant").size
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/ID").returns("abcdef0123456789", "returns the first Grant's Grantee ID") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/ID").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/EmailAddress").returns("user@example.com", "returns the second Grant's Grantee EmailAddress") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/EmailAddress").first.content
     end
 
     tests(".hash_to_acl(#{acl.inspect}) at xpath //AccessControlPolicy/AccessControlList/Grant/Grantee/URI").returns("http://acs.amazonaws.com/groups/global/AllUsers", "returns the third Grant's Grantee URI") do
-      xml = Fog::Storage::AWS.hash_to_acl(acl)
+      xml = Fog::AWS::Storage.hash_to_acl(acl)
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/URI").first.content
     end
   end
@@ -203,7 +203,7 @@ XML
         "Permission" => "FULL_CONTROL"
       }]
     }, 'returns hash of ACL XML') do
-      Fog::Storage::AWS.acl_to_hash(acl_xml)
+      Fog::AWS::Storage.acl_to_hash(acl_xml)
     end
   end
 end

data/tests/requests/storage/bucket_tests.rb

@@ -158,7 +158,7 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', ["aws"]) do
       Fog::Storage[:aws].put_bucket_website(@aws_bucket_name, :IndexDocument => 'index.html')
     end
 
-    tests("#put_bucket_website('#{@aws_bucket_name}', :RedirectAllRequestsTo => 'redirect.example..com')").succeeds do
+    tests("#put_bucket_website('#{@aws_bucket_name}', :RedirectAllRequestsTo => 'redirect.example.com')").succeeds do
       Fog::Storage[:aws].put_bucket_website(@aws_bucket_name, :RedirectAllRequestsTo => 'redirect.example.com')
     end
 

data/tests/requests/storage/cors_utils_tests.rb

@@ -1,14 +1,14 @@
 require 'fog/aws/requests/storage/cors_utils'
 
-Shindo.tests('Fog::Storage::AWS | CORS utils', ["aws"]) do
+Shindo.tests('Fog::AWS::Storage | 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({})
+      xml = Fog::AWS::Storage.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({})
+      xml = Fog::AWS::Storage.hash_to_cors({})
       Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule").first
     end
 
@@ -26,52 +26,52 @@ Shindo.tests('Fog::Storage::AWS | CORS utils', ["aws"]) do
     }
 
     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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.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)
+      xml = Fog::AWS::Storage.hash_to_cors(cors)
       Nokogiri::XML(xml).xpath("//CORSConfiguration/CORSRule/ExposeHeader")[1].content
     end
   end
@@ -102,7 +102,7 @@ XML
         "ExposeHeader" => ["x-amz-server-side-encryption", "x-amz-balls"]
       }]
     }, 'returns hash of CORS XML') do
-      Fog::Storage::AWS.cors_to_hash(cors_xml)
+      Fog::AWS::Storage.cors_to_hash(cors_xml)
     end
   end
 end

data/tests/requests/storage/multipart_copy_tests.rb

@@ -0,0 +1,93 @@
+require 'securerandom'
+
+Shindo.tests('Fog::Storage[:aws] | copy requests', ["aws"]) do
+
+  @directory = Fog::Storage[:aws].directories.create(:key => uniq_id('fogmultipartcopytests'))
+  @large_data = SecureRandom.hex * 600000
+  @large_blob = Fog::Storage[:aws].put_object(@directory.identity, 'large_object', @large_data)
+
+  tests('copies an empty object') do
+    Fog::Storage[:aws].put_object(@directory.identity, 'empty_object', '')
+
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('empty_object')
+    file.multipart_chunk_size = Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+
+    tests("#copy_object('#{@directory.identity}', 'empty_copied_object'").succeeds do
+      file.copy(@directory.identity, 'empty_copied_object')
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('empty_copied_object')
+    test("copied is the same") { copied.body == file.body }
+  end
+
+  tests('copies a small object') do
+    Fog::Storage[:aws].put_object(@directory.identity, 'fog_object', lorem_file)
+
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('fog_object')
+
+    tests("#copy_object('#{@directory.identity}', 'copied_object'").succeeds do
+      file.copy(@directory.identity, 'copied_object')
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('copied_object')
+    test("copied is the same") { copied.body == file.body }
+  end
+
+  tests('copies a file needing a single part') do
+    data = '*' * Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+    Fog::Storage[:aws].put_object(@directory.identity, '1_part_object', data)
+
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('1_part_object')
+    file.multipart_chunk_size = Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+
+    tests("#copy_object('#{@directory.identity}', '1_part_copied_object'").succeeds do
+      file.copy(@directory.identity, '1_part_copied_object')
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('1_part_copied_object')
+    test("copied is the same") { copied.body == file.body }
+  end
+
+  tests('copies a file with many parts') do
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('large_object')
+    file.multipart_chunk_size = Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+
+    tests("#copy_object('#{@directory.identity}', 'large_copied_object'").succeeds do
+      file.copy(@directory.identity, 'large_copied_object')
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('large_copied_object')
+
+    test("concurrency defaults to 1") { file.concurrency == 1 }
+    test("copied is the same") { copied.body == file.body }
+  end
+
+  tests('copies a file with many parts with 10 threads') do
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('large_object')
+    file.multipart_chunk_size = Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+    file.concurrency = 10
+
+    test("concurrency is set to 10") { file.concurrency == 10 }
+
+    tests("#copy_object('#{@directory.identity}', 'copied_object_with_10_threads'").succeeds do
+      file.copy(@directory.identity, 'copied_object_with_10_threads')
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('copied_object_with_10_threads')
+
+    test("copied is the same") { copied.body == file.body }
+  end
+
+  tests('copies an object with unknown headers') do
+    file = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('large_object')
+    file.multipart_chunk_size = Fog::AWS::Storage::File::MIN_MULTIPART_CHUNK_SIZE
+    file.concurrency = 10
+
+    tests("#copy_object('#{@directory.identity}', 'copied_object'").succeeds do
+      file.copy(@directory.identity, 'copied_object', { unknown: 1 } )
+    end
+
+    copied = Fog::Storage[:aws].directories.new(key: @directory.identity).files.get('copied_object')
+    test("copied is the same") { copied.body == file.body }
+  end
+end