fog-aws 0.12.0 → 0.13.0

data/lib/fog/aws/requests/efs/describe_mount_target_security_groups.rb

@@ -0,0 +1,34 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Describe mount target security groups
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DescribeMountTargetSecurityGroups.html
+        # ==== Parameters
+        # * MountTargetId - Id of the mount target for which you want to describe security groups
+        # ==== Returns
+        # * response<~Excon::Response>
+        # * body<~Hash>
+
+        def describe_mount_target_security_groups(mount_target_id)
+          request(
+            :path => "mount-targets/#{mount_target_id}/security-groups"
+          )
+        end
+      end
+
+      class Mock
+        def describe_mount_target_security_groups(mount_target_id)
+          response = Excon::Response.new
+
+          unless self.data[:mount_targets][mount_target_id]
+            raise Fog::AWS::EFS::NotFound.new("invalid mount target ID: #{mount_target_id}")
+          end
+
+          response.body = {"SecurityGroups" => self.data[:security_groups][mount_target_id]}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/describe_mount_targets.rb

@@ -0,0 +1,61 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        # Describe all mount targets for a filesystem, or specified mount target
+        # http://docs.aws.amazon.com/efs/latest/ug/API_DescribeMountTargets.html
+        # ==== Parameters
+        # * FileSystemId<~String> - Id of file system to describe mount targets for.  Required unless MountTargetId is specified
+        # * MountTargetId<~String> - Specific mount target to describe.  Required if FileSystemId is not specified
+        # ==== Returns
+        # * response<~Excon::Response>
+        #   * body<~Hash>
+        def describe_mount_targets(options={})
+          params = {}
+          if options[:marker]
+            params['Marker'] = options[:marker]
+          end
+          if options[:max_records]
+            params['MaxRecords'] = options[:max_records]
+          end
+          if options[:id]
+            params['MountTargetId'] = options[:id]
+          end
+          if options[:file_system_id]
+            params['FileSystemId'] = options[:file_system_id]
+          end
+
+          request({
+            :path => "mount-targets"
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def describe_mount_targets(options={})
+          response = Excon::Response.new
+
+          mount_targets = if id = options[:id]
+                            if mount_target = self.data[:mount_targets][id]
+                              [mount_target]
+                            else
+                              raise Fog::AWS::EFS::NotFound.new("Mount target does not exist.")
+                            end
+                          elsif file_system_id = options[:file_system_id]
+                            self.data[:mount_targets].values.select { |mt| mt["FileSystemId"] == file_system_id }
+                          else
+                            raise Fog::AWS::EFS::Error.new("file system ID or mount target ID must be specified")
+                          end
+
+          mount_targets.each do |mount_target|
+            mount_target['LifeCycleState'] = 'available'
+            self.data[:mount_targets][mount_target["MountTargetId"]] = mount_target
+          end
+
+          response.body = {"MountTargets" => mount_targets}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/efs/modify_mount_target_security_groups.rb

@@ -0,0 +1,39 @@
+module Fog
+  module AWS
+    class EFS
+      class Real
+        def modify_mount_target_security_groups(id, security_groups)
+          request({
+            :path            => "mount-targets/#{id}/security-groups",
+            :method          => "PUT",
+            :expects         => 204,
+            'SecurityGroups' => security_groups
+          })
+        end
+      end
+
+      class Mock
+        def modify_mount_target_security_groups(id, security_groups)
+          if security_groups.nil? || security_groups.empty?
+            raise Fog::AWS::EFS::Error.new("Must provide at least one security group.")
+          end
+
+          response = Excon::Response.new
+
+          unless self.data[:mount_targets][id]
+            raise Fog::AWS::EFS::NotFound.new("invalid mount target ID: #{id}")
+          end
+
+          security_groups.each do |sg|
+            raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{sg}") unless mock_compute.data[:security_groups].values.detect { |sgd| sgd["groupId"] == sg }
+          end
+
+          self.data[:security_groups][id] = security_groups
+
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/modify_db_subnet_group.rb

@@ -0,0 +1,27 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/modify_db_subnet_group.rb'
+
+        # Creates a db subnet group
+        # http://docs.aws.amazon.com/AmazonRDS/2012-01-15/APIReference/API_ModifyDBSubnetGroup.html
+        # ==== Parameters
+        # * DBSubnetGroupName <~String> - The name for the DB Subnet Group. This value is stored as a lowercase string. Must contain no more than 255 alphanumeric characters or hyphens. Must not be "Default".
+        # * SubnetIds <~Array> - The EC2 Subnet IDs for the DB Subnet Group.
+        # * DBSubnetGroupDescription <~String> - The description for the DB Subnet Group
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def modify_db_subnet_group(name, subnet_ids, description = nil)
+          params = { 'Action'  => 'ModifyDBSubnetGroup',
+            'DBSubnetGroupName' => name,
+            'DBSubnetGroupDescription' => description,
+            :parser   => Fog::Parsers::AWS::RDS::ModifyDBSubnetGroup.new }
+          params.merge!(Fog::AWS.indexed_param("SubnetIds.member", Array(subnet_ids)))
+          request(params)
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/storage/delete_multiple_objects.rb

@@ -46,7 +46,7 @@ module Fog
           end
           data << "</Delete>"
 
-          headers['Content-Length'] = data.length
+          headers['Content-Length'] = data.bytesize
           headers['Content-MD5'] = Base64.encode64(OpenSSL::Digest::MD5.digest(data)).
                                    gsub("\n", '')
 

data/lib/fog/aws/requests/sts/assume_role.rb

@@ -39,6 +39,31 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def assume_role(role_session_name, role_arn, external_id=nil, policy=nil, duration=3600)
+          account_id = /[0-9]{12}/.match(role_arn)
+          request_id = Fog::AWS::Mock.request_id
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+
+            response.body = {
+              'Arn'             => "arn:aws:sts::#{account_id}:assumed-role/#{role_session_name}/#{role_session_name}",
+              'AssumedRoleId'   => "#{Fog::Mock.random_base64(21)}:#{role_session_name}",
+              'AccessKeyId'     => Fog::Mock.random_base64(20),
+              'SecretAccessKey' => Fog::Mock.random_base64(40),
+              'SessionToken'    => Fog::Mock.random_base64(580),
+              'Expiration'      => (Time.now + duration).utc.iso8601,
+              'RequestId'       => request_id,
+            }
+
+            response.headers = {
+              'x-amzn-RequestId' => request_id,
+            }
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/aws/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AWS
-    VERSION = "0.12.0"
+    VERSION = "0.13.0"
   end
 end

data/tests/helper.rb

@@ -1,6 +1,7 @@
 begin
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
+  require 'simplecov'
+  SimpleCov.start
+  SimpleCov.command_name "Shindo"
 rescue LoadError => e
   $stderr.puts "not recording test coverage: #{e.inspect}"
 end

data/tests/models/efs/file_system_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests("AWS::EFS | file system", ["aws", "efs"]) do
+  file_system_params = {
+    :creation_token => "fogtoken#{rand(999).to_s}"
+  }
+
+  model_tests(Fog::AWS[:efs].file_systems, file_system_params, true)
+
+  file_system_params = {
+    :creation_token => "fogtoken#{rand(999).to_s}"
+  }
+  collection_tests(Fog::AWS[:efs].file_systems, file_system_params, true)
+end

data/tests/models/efs/mount_target_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests("AWS::EFS | mount target", ["aws", "efs"]) do
+  @file_system = Fog::AWS[:efs].file_systems.create(:creation_token => "fogtoken#{rand(999).to_s}")
+  @file_system.wait_for { ready? }
+
+  if Fog.mocking?
+    vpc = Fog::Compute[:aws].vpcs.create(:cidr_block => "10.0.0.0/16")
+    subnet = Fog::Compute[:aws].subnets.create(:vpc_id => vpc.id, :cidr_block => "10.0.1.0/24")
+    default_security_group_data = Fog::Compute[:aws].data[:security_groups]['default']
+    default_security_group = Fog::Compute[:aws].security_groups.new(default_security_group_data)
+  else
+    vpc = Fog::Compute[:aws].vpcs.first
+    subnet = vpc.subnets.first
+    default_security_group = Fog::Compute[:aws].security_groups.detect { |sg| sg.description == 'default VPC security group' }
+  end
+
+  security_group = Fog::Compute[:aws].security_groups.create(
+    :vpc_id      => vpc.id,
+    :name        => "fog#{rand(999).to_s}",
+    :description => "fog#{rand(999).to_s}"
+  )
+
+  mount_target_params = {
+    :file_system_id  => @file_system.identity,
+    :subnet_id       => subnet.identity,
+  }
+
+  model_tests(Fog::AWS[:efs].mount_targets, mount_target_params, true) do
+    @instance.wait_for { ready? }
+
+    tests("#security_groups") do
+      returns([default_security_group.group_id]) { @instance.security_groups }
+    end
+
+    tests("#security_groups=") do
+      @instance.security_groups = [security_group.group_id]
+      returns([security_group.group_id]) { @instance.security_groups }
+    end
+  end
+
+  @file_system.wait_for { number_of_mount_targets == 0 }
+  @file_system.destroy
+  security_group.destroy
+end

data/tests/models/efs/mount_targets_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests("AWS::EFS | mount targets", ["aws", "efs"]) do
+  @file_system = Fog::AWS[:efs].file_systems.create(:creation_token => "fogtoken#{rand(999).to_s}")
+  @file_system.wait_for { ready? }
+
+  if Fog.mocking?
+    vpc = Fog::Compute[:aws].vpcs.create(:cidr_block => "10.0.0.0/16")
+    subnet = Fog::Compute[:aws].subnets.create(:vpc_id => vpc.id, :cidr_block => "10.0.1.0/24")
+  else
+    vpc = Fog::Compute[:aws].vpcs.first
+    subnet = vpc.subnets.first
+  end
+
+  security_group = Fog::Compute[:aws].security_groups.create(
+    :vpc_id      => vpc.id,
+    :name        => "fog#{rand(999).to_s}",
+    :description => "fog#{rand(999).to_s}"
+  )
+
+  mount_target_params = {
+    :file_system_id  => @file_system.identity,
+    :subnet_id       => subnet.identity,
+    :security_groups => [security_group.group_id]
+  }
+
+  collection_tests(Fog::AWS[:efs].mount_targets(:file_system_id => @file_system.identity), mount_target_params, true)
+
+  @file_system.wait_for { number_of_mount_targets == 0 }
+  @file_system.destroy
+  security_group.destroy
+end

data/tests/requests/auto_scaling/helper.rb

@@ -98,6 +98,7 @@ class AWS
         'Status' => Fog::Nullable::String,
         'SuspendedProcesses' => [SUSPENDED_PROCESS],
         'Tags' => [TAG_DESCRIPTION],
+        'TargetGroupARNs' => Array,
         'TerminationPolicies' => [String],
         'VPCZoneIdentifier' => Fog::Nullable::String
       }

data/tests/requests/compute/image_tests.rb

@@ -21,7 +21,9 @@ Shindo.tests('Fog::Compute[:aws] | image requests', ['aws']) do
       'rootDeviceType'      => String,
       'stateReason'         => {},
       'tagSet'              => {},
-      'virtualizationType'  => String
+      'virtualizationType'  => String,
+      'creationDate' => Fog::Nullable::Time,
+      'enaSupport' => Fog::Nullable::Boolean
     }],
     'requestId'     => String,
   }

data/tests/requests/efs/file_system_tests.rb

@@ -0,0 +1,152 @@
+Shindo.tests('AWS::EFS | file systems', ['aws', 'efs']) do
+  suffix = rand(65535).to_s(16)
+
+  @creation_token = "fogtest#{suffix}"
+
+  tests('success') do
+    tests("#create_file_system('#{@creation_token}')").formats(AWS::EFS::Formats::FILE_SYSTEM_FORMAT) do
+      result = Fog::AWS[:efs].create_file_system(@creation_token).body
+      returns('creating') { result['LifeCycleState'] }
+      result
+    end
+
+    tests("#describe_file_systems").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
+      Fog::AWS[:efs].describe_file_systems.body
+    end
+
+    tests("#describe_file_systems(creation_token: #{@creation_token})").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
+      result = Fog::AWS[:efs].describe_file_systems(:creation_token => @creation_token).body
+      returns(@creation_token) { result["FileSystems"].first["CreationToken"] }
+      result
+    end
+
+    file_system_id = Fog::AWS[:efs].describe_file_systems(:creation_token => @creation_token).body["FileSystems"].first["FileSystemId"]
+    file_system = Fog::AWS[:efs].file_systems.get(file_system_id)
+
+    tests("#describe_file_systems(id: #{file_system_id})").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
+      Fog::AWS[:efs].describe_file_systems(:id => file_system_id).body
+    end
+
+    if Fog.mocking?
+      vpc    = Fog::Compute[:aws].vpcs.create(:cidr_block => "10.0.0.0/16")
+      subnet = Fog::Compute[:aws].subnets.create(
+        :vpc_id     => vpc.id,
+        :cidr_block => "10.0.1.0/24"
+      )
+      default_security_group = Fog::Compute[:aws].security_groups.detect { |sg| sg.description == 'default group' }
+    else
+      vpc = Fog::Compute[:aws].vpcs.first
+      subnet = vpc.subnets.first
+      default_security_group = Fog::Compute[:aws].security_groups.detect { |sg| sg.description == 'default VPC security group' }
+    end
+
+    security_group = Fog::Compute[:aws].security_groups.create(
+      :vpc_id      => vpc.id,
+      :name        => "fog#{suffix}",
+      :description => "fog#{suffix}"
+    )
+
+    raises(Fog::AWS::EFS::InvalidSubnet, "invalid subnet ID: foobar#{suffix}") do
+      Fog::AWS[:efs].create_mount_target(file_system_id, "foobar#{suffix}")
+    end
+
+    raises(Fog::AWS::EFS::NotFound, "invalid file system ID: foobar#{suffix}") do
+      Fog::AWS[:efs].create_mount_target("foobar#{suffix}", subnet.identity)
+    end
+
+    if Fog.mocking?
+      tests("#create_mount_target") do
+        Fog::AWS[:efs].data[:file_systems][file_system_id]["LifeCycleState"] = 'creating'
+        raises(Fog::AWS::EFS::IncorrectFileSystemLifeCycleState) do
+          Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity)
+        end
+
+        Fog::AWS[:efs].data[:file_systems][file_system_id]["LifeCycleState"] = 'available'
+      end
+    end
+
+    raises(Fog::AWS::EFS::NotFound, "invalid security group ID: foobar#{suffix}") do
+      Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity, 'SecurityGroups' => ["foobar#{suffix}"])
+    end
+
+    tests("#create_mount_target(#{file_system_id}, #{subnet.identity})").formats(AWS::EFS::Formats::MOUNT_TARGET_FORMAT) do
+      Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity).body
+    end
+
+    tests("#describe_mount_targets(file_system_id: #{file_system_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGETS_RESULT) do
+      Fog::AWS[:efs].describe_mount_targets(:file_system_id => file_system_id).body
+    end
+
+    mount_target_id = Fog::AWS[:efs].describe_mount_targets(:file_system_id => file_system_id).body["MountTargets"].first["MountTargetId"]
+
+    tests("#describe_mount_target_security_groups(#{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGET_SECURITY_GROUPS_FORMAT) do
+      result = Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body
+      returns([default_security_group.group_id]) { result["SecurityGroups"] }
+      result
+    end
+
+    raises(Fog::AWS::EFS::Error, 'Must provide at least one security group.') do
+      Fog::AWS[:efs].modify_mount_target_security_groups(mount_target_id, [])
+    end
+
+    tests("#modify_mount_target_security_groups(#{mount_target_id}, [#{security_group.group_id}])") do
+      returns(204) do
+        Fog::AWS[:efs].modify_mount_target_security_groups(mount_target_id, [security_group.group_id]).status
+      end
+    end
+
+    Fog.wait_for { Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body["SecurityGroups"] != [default_security_group.group_id] }
+
+    tests("#describe_mount_target_security_groups(#{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGET_SECURITY_GROUPS_FORMAT) do
+      result = Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body
+      returns([security_group.group_id]) { result["SecurityGroups"] }
+      result
+    end
+
+    tests("#describe_mount_targets(id: #{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGETS_RESULT) do
+      Fog::AWS[:efs].describe_mount_targets(:id => mount_target_id).body
+    end
+
+    raises(Fog::AWS::EFS::NotFound, 'Mount target does not exist.') do
+      Fog::AWS[:efs].describe_mount_targets(:id => "foobar")
+    end
+
+    raises(Fog::AWS::EFS::Error, 'file system ID or mount target ID must be specified') do
+      Fog::AWS[:efs].describe_mount_targets
+    end
+
+    raises(Fog::AWS::EFS::NotFound, "invalid mount target id: foobar#{suffix}") do
+      Fog::AWS[:efs].delete_mount_target("foobar#{suffix}")
+    end
+
+    tests("#delete_mount_target(id: #{mount_target_id})") do
+      returns(true) do
+        result = Fog::AWS[:efs].delete_mount_target(mount_target_id)
+        result.body.empty?
+      end
+    end
+
+    file_system.wait_for { number_of_mount_targets == 0 }
+
+    if Fog.mocking?
+      Fog::AWS[:efs].data[:file_systems][file_system_id]["NumberOfMountTargets"] = 1
+      raises(Fog::AWS::EFS::FileSystemInUse) do
+        Fog::AWS[:efs].delete_file_system(file_system_id)
+      end
+      Fog::AWS[:efs].data[:file_systems][file_system_id]["NumberOfMountTargets"] = 0
+    end
+
+    raises(Fog::AWS::EFS::NotFound, "invalid file system ID: foobar#{suffix}") do
+      Fog::AWS[:efs].delete_file_system("foobar#{suffix}")
+    end
+
+    tests("#delete_file_system") do
+      returns(true) do
+        result = Fog::AWS[:efs].delete_file_system(file_system_id)
+        result.body.empty?
+      end
+    end
+
+    security_group.destroy
+  end
+end