fog-aws 3.0.0 → 3.10.0

data/tests/helpers/model_helper.rb

@@ -1,9 +1,8 @@
 def model_tests(collection, params = {}, mocks_implemented = true)
   tests('success') do
-
     @instance = collection.new(params)
 
-    tests("#save").succeeds do
+    tests('#save').succeeds do
       pending if Fog.mocking? && !mocks_implemented
       @instance.save
     end
@@ -12,7 +11,7 @@ def model_tests(collection, params = {}, mocks_implemented = true)
       yield(@instance)
     end
 
-    tests("#destroy").succeeds do
+    tests('#destroy').succeeds do
       pending if Fog.mocking? && !mocks_implemented
       @instance.destroy
     end
@@ -26,6 +25,6 @@ end
 # E.g. 'fog-test-1234'
 def uniq_id(base_name = 'fog-test')
   # random_differentiator
-  suffix = rand(65536).to_s(16).rjust(4, '0')
-  [base_name, suffix] * '-'
+  suffix = rand(65_536).to_s(16).rjust(4, '0')
+  [base_name, suffix].join('-')
 end

data/tests/helpers/responds_to_helper.rb

@@ -1,7 +1,7 @@
 module Shindo
   class Tests
     def responds_to(method_names)
-      for method_name in [*method_names]
+      [*method_names].each do |method_name|
         tests("#respond_to?(:#{method_name})").returns(true) do
           @instance.respond_to?(method_name)
         end

data/tests/helpers/schema_validator_tests.rb

@@ -1,37 +1,37 @@
+# frozen_string_literal: true
+
 Shindo.tests('Fog::Schema::DataValidator', 'meta') do
 
   validator = Fog::Schema::DataValidator.new
 
   tests('#validate') do
-
     tests('returns true') do
-
       returns(true, 'when value matches schema expectation') do
-        validator.validate({"key" => "Value"}, {"key" => String})
+        validator.validate({ 'key' => 'Value' }, 'key' => String)
       end
 
       returns(true, 'when values within an array all match schema expectation') do
-        validator.validate({"key" => [1, 2]}, {"key" => [Integer]})
+        validator.validate({ 'key' => [1, 2] }, 'key' => [Integer])
       end
 
       returns(true, 'when nested values match schema expectation') do
-        validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}})
+        validator.validate({ 'key' => { nested_key: 'Value' } }, 'key' => { nested_key: String })
       end
 
       returns(true, 'when collection of values all match schema expectation') do
-        validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}])
+        validator.validate([{ 'key' => 'Value' }, 'key' => 'Value'], [{ 'key' => String }])
       end
 
       returns(true, 'when collection is empty although schema covers optional members') do
-        validator.validate([], [{"key" => String}])
+        validator.validate([], [{ 'key' => String }])
       end
 
       returns(true, 'when additional keys are passed and not strict') do
-        validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true})
+        validator.validate({ 'key' => 'Value', extra: 'Bonus' }, { 'key' => String }, allow_extra_keys: true)
       end
 
       returns(true, 'when value is nil and schema expects NilClass') do
-        validator.validate({"key" => nil}, {"key" => NilClass})
+        validator.validate({ 'key' => nil }, 'key' => NilClass)
       end
 
       returns(true, 'when value and schema match as hashes') do
@@ -43,43 +43,41 @@ Shindo.tests('Fog::Schema::DataValidator', 'meta') do
       end
 
       returns(true, 'when value is a Time') do
-        validator.validate({"time" => Time.now}, {"time" => Time})
+        validator.validate({ 'time' => Time.now }, 'time' => Time)
       end
 
       returns(true, 'when key is missing but value should be NilClass (#1477)') do
-        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true})
+        validator.validate({}, { 'key' => NilClass }, allow_optional_rules: true)
       end
 
       returns(true, 'when key is missing but value is nullable (#1477)') do
-        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true})
+        validator.validate({}, { 'key' => Fog::Nullable::String }, allow_optional_rules: true)
       end
-
     end
 
     tests('returns false') do
-
       returns(false, 'when value does not match schema expectation') do
-        validator.validate({"key" => nil}, {"key" => String})
+        validator.validate({ 'key' => nil }, 'key' => String)
       end
 
       returns(false, 'when key formats do not match') do
-        validator.validate({"key" => "Value"}, {:key => String})
+        validator.validate({ 'key' => 'Value' }, key: String)
       end
 
       returns(false, 'when additional keys are passed and strict') do
-        validator.validate({"key" => "Missing"}, {})
+        validator.validate({ 'key' => 'Missing' }, {})
       end
 
       returns(false, 'when some keys do not appear') do
-        validator.validate({}, {"key" => String})
+        validator.validate({}, 'key' => String)
       end
 
       returns(false, 'when collection contains a member that does not match schema') do
-        validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}])
+        validator.validate([{ 'key' => 'Value' }, 'key' => 5], ['key' => String])
       end
 
       returns(false, 'when collection has multiple schema patterns') do
-        validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}])
+        validator.validate([{ 'key' => 'Value' }], [{ 'key' => Integer }, { 'key' => String }])
       end
 
       returns(false, 'when hash and array are compared') do
@@ -91,17 +89,16 @@ Shindo.tests('Fog::Schema::DataValidator', 'meta') do
       end
 
       returns(false, 'when a hash is expected but another data type is found') do
-        validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}})
+        validator.validate({ 'key' => { nested_key: [] } }, 'key' => { nested_key: {} })
       end
 
       returns(false, 'when key is missing but value should be NilClass (#1477)') do
-        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false})
+        validator.validate({}, { 'key' => NilClass }, allow_optional_rules: false)
       end
 
       returns(false, 'when key is missing but value is nullable (#1477)') do
-        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false})
+        validator.validate({}, { 'key' => Fog::Nullable::String }, allow_optional_rules: false)
       end
-
     end
   end
 end

data/tests/helpers/succeeds_helper.rb

@@ -1,8 +1,8 @@
 module Shindo
   class Tests
-    def succeeds
+    def succeeds(&block)
       test('succeeds') do
-        !!instance_eval(&Proc.new)
+        !instance_eval(&Proc.new(&block)).nil?
       end
     end
   end

data/tests/models/compute/address_tests.rb

@@ -36,7 +36,7 @@ Shindo.tests("Fog::Compute[:aws] | address", ['aws']) do
   end
 
   model_tests(Fog::Compute[:aws].addresses, { :domain => "vpc" }, true) do
-    tests("#change_scope").raises(Fog::Compute::AWS::Error) do
+    tests("#change_scope").raises(Fog::AWS::Compute::Error) do
       @instance.change_scope
     end
   end

data/tests/models/compute/network_acl_tests.rb

@@ -38,7 +38,7 @@ Shindo.tests("Fog::Compute[:aws] | network_acl", ['aws']) do
     default_rules = @new_nacl.entries.dup
 
     test("add a new inbound rule") do
-      @new_nacl.add_inbound_rule(100, Fog::Compute::AWS::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
+      @new_nacl.add_inbound_rule(100, Fog::AWS::Compute::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
       @new_nacl.reload
       (@new_nacl.entries - default_rules) == [{
         "icmpTypeCode" => {},
@@ -61,7 +61,7 @@ Shindo.tests("Fog::Compute[:aws] | network_acl", ['aws']) do
     end
 
     test("add a new outbound rule") do
-      @new_nacl.add_outbound_rule(100, Fog::Compute::AWS::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
+      @new_nacl.add_outbound_rule(100, Fog::AWS::Compute::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
       @new_nacl.reload
       (@new_nacl.entries - default_rules) == [{
         "icmpTypeCode" => {},
@@ -84,8 +84,8 @@ Shindo.tests("Fog::Compute[:aws] | network_acl", ['aws']) do
     end
 
     test("update rule") do
-      @new_nacl.add_inbound_rule(100, Fog::Compute::AWS::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
-      @new_nacl.update_inbound_rule(100, Fog::Compute::AWS::NetworkAcl::TCP, 'allow', '10.0.0.0/8', 'PortRange.From' => 22, 'PortRange.To' => 22)
+      @new_nacl.add_inbound_rule(100, Fog::AWS::Compute::NetworkAcl::TCP, 'allow', '0.0.0.0/0', 'PortRange.From' => 22, 'PortRange.To' => 22)
+      @new_nacl.update_inbound_rule(100, Fog::AWS::Compute::NetworkAcl::TCP, 'allow', '10.0.0.0/8', 'PortRange.From' => 22, 'PortRange.To' => 22)
       @new_nacl.reload
       (@new_nacl.entries - default_rules) == [{
         "icmpTypeCode" => {},

data/tests/models/compute/security_group_tests.rb

@@ -85,7 +85,7 @@ Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
       { @other_user_id => @other_users_group_id }
     ].each do |group_arg|
       test("does not authorize port range access by an invalid security group #{group_arg.inspect}") do
-        raises(Fog::Compute::AWS::NotFound, "The security group '#{@other_users_group_id}' does not exist") {
+        raises(Fog::AWS::Compute::NotFound, "The security group '#{@other_users_group_id}' does not exist") {
           @other_group.reload
           @group.authorize_port_range(5000..6000, {:group => group_arg})
         }

data/tests/models/compute/volume_tests.rb

@@ -25,7 +25,7 @@ Shindo.tests('Fog::Compute[:aws] | volume', ['aws']) do
       @instance.server.nil?
     end
 
-    tests('#server=').raises(NoMethodError, 'use Fog::Compute::AWS::Volume#attach(server, device)') do
+    tests('#server=').raises(NoMethodError, 'use Fog::AWS::Compute::Volume#attach(server, device)') do
       @instance.server = @server
     end
 

data/tests/models/elb/model_tests.rb

@@ -1,5 +1,5 @@
 Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
-  Fog::Compute::AWS::Mock.reset if Fog.mocking?
+  Fog::AWS::Compute::Mock.reset if Fog.mocking?
   @availability_zones = Fog::Compute[:aws].describe_availability_zones('state' => 'available').body['availabilityZoneInfo'].map{ |az| az['zoneName'] }
   @key_name = 'fog-test-model'
   @vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')

data/tests/models/storage/directory_tests.rb

@@ -1,4 +1,117 @@
 Shindo.tests("Storage[:aws] | directory", ["aws"]) do
+  tests('Fog::Storage[:aws]', "#request_params") do
+    def slice(hash, *args)
+      hash.select { |k, _| args.include?(k) }
+    end
+
+    instance = Fog::Storage[:aws]
+    method = instance.method(:request_params)
+
+    params = {bucket_name: 'profile-uploads', host: 'profile-uploads.s3.us-west-2.amazonaws.com'}
+    tests("given #{params}, request_params[:host]").returns("profile-uploads.s3.us-west-2.amazonaws.com") do
+      method.call(params)[:host]
+    end
+
+    params = {bucket_name: 'profile-uploads.johnsmith.net', cname: 'profile-uploads.johnsmith.net', virtual_host: true}
+    tests("given #{params}, request_params[:host]").returns("profile-uploads.johnsmith.net") do
+      method.call(params)[:host]
+    end
+
+    params = {bucket_name: 'profile-uploads.johnsmith.net', cname: 'profile-uploads.johnsmith.net', virtual_host: false}
+    tests("given #{params}, request_params[:host], request_params[:path]").
+      returns({host: "s3.amazonaws.com", path: "/profile-uploads.johnsmith.net/"}) do
+      slice(method.call(params), :host, :path)
+    end
+
+    params = {bucket_name: 'profile-uploads.johnsmith.net', bucket_cname: 'profile-uploads.johnsmith.net'}
+    tests("given #{params}, request_params[:host]").returns("profile-uploads.johnsmith.net") do
+      method.call(params)[:host]
+    end
+
+    params = {bucket_name: 'profile-uploads'}
+    tests("given #{params}, request_params[:path], request_params[:host]").
+      returns({path: "/", host: "profile-uploads.s3.amazonaws.com"}) do
+        slice(method.call(params), :path, :host)
+      end
+
+    params = {bucket_name: 'profile-uploads', path_style: true}
+    tests("given #{params}, request_params[:path], request_params[:host]").
+      returns({path: "/profile-uploads/", host: "s3.amazonaws.com"}) do
+        slice(method.call(params), :path, :host)
+      end
+
+    params = {bucket_name: 'profile-uploads', path_style: false}
+    tests("given #{params}, request_params[:path], request_params[:host]").
+      returns({path: "/", host: "profile-uploads.s3.amazonaws.com"}) do
+        slice(method.call(params), :path, :host)
+      end
+
+    params = {scheme: 'https', bucket_name: 'profile.uploads', path_style: false}
+    tests("given #{params}, request_params[:path], request_params[:host]").
+      returns(path: "/profile.uploads/", host: "s3.amazonaws.com") do
+        slice(method.call(params), :path, :host)
+      end
+
+    params = {:headers=>{:"Content-Type"=>"application/json"}}
+    tests("given #{params}, request_params[:headers]").returns({:"Content-Type"=>"application/json"}) do
+      method.call(params)[:headers]
+    end
+
+    params = {headers: {}}
+    tests("given #{params}, request_params[:headers]").returns({}) do
+      method.call(params)[:headers]
+    end
+
+    params = {scheme: 'http'}
+    tests("given #{params}, request_params[:scheme]").returns('http') do
+      method.call(params)[:scheme]
+    end
+
+    params = {}
+    tests("given #{params}, request_params[:scheme]").returns('https') do
+      method.call(params)[:scheme]
+    end
+
+    params = {scheme: 'http', port: 8080}
+    tests("given #{params} (default scheme), request_params[:port]").returns(8080) do
+      method.call(params)[:port]
+    end
+
+    params = {scheme: 'https', port: 443}
+    tests("given #{params}, request_params[:port]").returns(nil) do
+      method.call(params)[:port]
+    end
+
+    params = {}
+    tests("given #{params}, request_params[:host]").returns("s3.amazonaws.com") do
+      method.call(params)[:host]
+    end
+
+    params = {region: 'us-east-1'}
+    tests("given #{params}, request_params[:host]").returns("s3.amazonaws.com") do
+      method.call(params)[:host]
+    end
+
+    params = {region: 'us-west-2'}
+    tests("given #{params}, request_params[:host]").returns("s3.us-west-2.amazonaws.com") do
+      method.call(params)[:host]
+    end
+
+    params= {region: 'us-east-1', host: 's3.us-west-2.amazonaws.com'}
+    tests("given #{params}, request_params[:host]").returns("s3.us-west-2.amazonaws.com") do
+      method.call(params)[:host]
+    end
+
+    params = {object_name: 'image.png'}
+    tests("given #{params}, request_params[:host]").returns("/image.png") do
+      method.call(params)[:path]
+    end
+
+    params = {object_name: 'image.png', path: '/images/image.png'}
+    tests("given #{params}, request_params[:host]").returns("/images/image.png") do
+      method.call(params)[:path]
+    end
+  end
 
   directory_attributes = {
     :key => uniq_id('fogdirectorytests')
@@ -85,7 +198,5 @@ Shindo.tests("Storage[:aws] | directory", ["aws"]) do
         @instance.versioning?
       end
     end
-
   end
-
 end

data/tests/models/storage/files_tests.rb

@@ -50,6 +50,38 @@ Shindo.tests("Storage[:aws] | files", ["aws"]) do
       end
     end
 
+    tests('#normalize_headers') do
+      files = @directory.files
+      response = Excon::Response.new
+      current_time = Time.new(2021, 02, 21)
+
+      response.headers['last-modified'] = current_time.to_s
+      response.headers['etag'] = '12345'
+      response.headers['ETAG'] = '12345'
+      response.headers['Cache-Control'] = 'no-cache'
+      response.headers['Content-disposition'] = 'attachment'
+      response.headers['content-length'] = 100
+      response.headers['content-Encoding'] = 'gzip'
+      response.headers['content-md5'] = 'ABCDEAB'
+      response.headers['content-Md5'] = 'ABCDEAB'
+      response.headers['ConTent-Type'] = 'application/json'
+
+      expected = {
+        'Last-Modified' => current_time,
+        'ETag' => '12345',
+        'Cache-Control' => 'no-cache',
+        'Content-Disposition' => 'attachment',
+        'Content-Length' => 100,
+        'Content-Encoding' => 'gzip',
+        'Content-MD5' => 'ABCDEAB',
+        'Content-Type' => 'application/json'
+      }
+
+      tests('header keys are normalized').returns(expected) do
+        files.normalize_headers(response)
+        response.headers
+      end
+    end
   end
 
   @directory.versions.each(&:destroy)

data/tests/parsers/compute/describe_images_tests.rb

@@ -24,9 +24,9 @@ DESCRIBE_IMAGES_RESULT = <<-EOF
 </DescribeImagesResponse>
 EOF
 
-Shindo.tests('Compute::AWS | parsers | describe_images', ['compute', 'aws', 'parser']) do
+Shindo.tests('AWS::Compute | parsers | describe_images', %w[compute aws parser]) do
   tests('parses the xml').formats(AWS::Compute::Formats::DESCRIBE_IMAGES) do
-    parser = Nokogiri::XML::SAX::Parser.new(Fog::Parsers::Compute::AWS::DescribeImages.new)
+    parser = Nokogiri::XML::SAX::Parser.new(Fog::Parsers::AWS::Compute::DescribeImages.new)
     parser.parse(DESCRIBE_IMAGES_RESULT)
     parser.document.response
   end

data/tests/parsers/elb/describe_load_balancers.rb

@@ -56,7 +56,7 @@ xmlns="http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/">
 </DescribeLoadBalancersResponse>
 EOF
 
-Shindo.tests('AWS::ELB | parsers | describe_load_balancers', ['aws', 'elb', 'parser']) do
+Shindo.tests('AWS::ELB | parsers | describe_load_balancers', %w[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)

data/tests/parsers/elbv2/create_load_balancer_tests.rb

@@ -0,0 +1,48 @@
+require 'fog/xml'
+require 'fog/aws/parsers/elbv2/create_load_balancer'
+
+CREATE_LOAD_BALANCER_RESULT = <<-EOF
+<CreateLoadBalancerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
+  <CreateLoadBalancerResult>
+    <LoadBalancers>
+      <member>
+        <LoadBalancerArn>arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-internal-load-balancer/50dc6c495c0c9188</LoadBalancerArn>
+        <Scheme>internet-facing</Scheme>
+        <LoadBalancerName>my-load-balancer</LoadBalancerName>
+        <VpcId>vpc-3ac0fb5f</VpcId>
+        <CanonicalHostedZoneId>Z2P70J7EXAMPLE</CanonicalHostedZoneId>
+        <CreatedTime>2016-03-25T21:29:48.850Z</CreatedTime>
+        <AvailabilityZones>
+          <member>
+            <SubnetId>subnet-8360a9e7</SubnetId>
+            <ZoneName>us-west-2a</ZoneName>
+          </member>
+          <member>
+            <SubnetId>subnet-b7d581c0</SubnetId>
+            <ZoneName>us-west-2b</ZoneName>
+          </member>
+        </AvailabilityZones>
+        <SecurityGroups>
+          <member>sg-5943793c</member>
+        </SecurityGroups>
+        <DNSName>my-load-balancer-424835706.us-west-2.elb.amazonaws.com</DNSName>
+        <State>
+          <Code>provisioning</Code>
+        </State>
+        <Type>application</Type>
+      </member>
+    </LoadBalancers>
+  </CreateLoadBalancerResult>
+  <ResponseMetadata>
+    <RequestId>32d531b2-f2d0-11e5-9192-3fff33344cfa</RequestId>
+  </ResponseMetadata>
+</CreateLoadBalancerResponse>
+EOF
+
+Shindo.tests('AWS::ELBV2 | parsers | create_load_balancer', %w[aws elb parser]) do
+  tests('parses the xml').formats(AWS::ELBV2::Formats::CREATE_LOAD_BALANCER) do
+    parser = Nokogiri::XML::SAX::Parser.new(Fog::Parsers::AWS::ELBV2::CreateLoadBalancer.new)
+    parser.parse(CREATE_LOAD_BALANCER_RESULT)
+    parser.document.response
+  end
+end