fog-aws 0.11.0 → 3.18.0

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -80,7 +80,7 @@ module Fog
                    elsif subnet_ids.any?
                      # using Hash here for Rubt 1.8.7 support.
                      Hash[
-                       Fog::Compute::AWS::Mock.data.select do |_, region_data|
+                       Fog::AWS::Compute::Mock.data.select do |_, region_data|
                          region_data[@aws_access_key_id][:subnets].any? do |region_subnets|
                            subnet_ids.include? region_subnets['subnetId']
                          end
@@ -89,8 +89,8 @@ module Fog
                    else
                      'us-east-1'
                    end
-          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
-          subnets = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
+          supported_platforms = Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
+          subnets = Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
 
           # http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/default-vpc.html
           elb_location = if supported_platforms.include?("EC2")
@@ -109,55 +109,24 @@ module Fog
 
           security_group = case elb_location
                            when 'EC2-Classic'
-                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
+                             Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
                            when 'EC2-VPC-Default'
-                             # find or create default vpc
-                             compute = Fog::Compute::AWS::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
-                             unless vpc = compute.vpcs.all.first
-                               vpc = compute.vpcs.create('cidr_block' => '10.0.0.0/24')
-                             end
+                             compute = Fog::AWS::Compute::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
 
-                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+                             vpc = compute.vpcs.all.first ||
+                               compute.vpcs.create('cidr_block' => '10.0.0.0/24')
+
+                             Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
                                sg['groupName'] =~ /^default_elb/ &&
                                  sg["vpcId"] == vpc.id
                              }
-
-                             unless default_sg
-                               default_sg = {
-                                             'groupDescription'    => 'default_elb security group',
-                                             'groupName'           => "default_elb_#{Fog::Mock.random_hex(6)}",
-                                             'groupId'             => Fog::AWS::Mock.security_group_id,
-                                             'ipPermissionsEgress' => [],
-                                             'ipPermissions'       => [],
-                                             'ownerId'             => self.data[:owner_id],
-                                             'vpcId'               => vpc.id
-                                            }
-                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
-                             end
-
-                             default_sg
                            when 'EC2-VPC'
-                             # find or create default vpc security group
                              vpc_id = subnets.first["vpcId"]
-                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+
+                             Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
                                sg['groupName'] == 'default' &&
                                  sg["vpcId"] == vpc_id
                              }
-
-                             unless default_sg
-                               default_sg = {
-                                             'groupDescription'    => 'default elb security group',
-                                             'groupName'           => 'default',
-                                             'groupId'             => Fog::AWS::Mock.security_group_id,
-                                             'ipPermissionsEgress' => [],
-                                             'ipPermissions'       => [],
-                                             'ownerId'             => self.data[:owner_id],
-                                             'vpcId'               => vpc_id
-                                            }
-                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
-                             end
-
-                             default_sg
                            end
           self.data[:tags] ||= {}
           self.data[:tags][lb_name] = {}

data/lib/fog/aws/requests/elb/create_load_balancer_listeners.rb

@@ -51,34 +51,37 @@ module Fog
 
       class Mock
         def create_load_balancer_listeners(lb_name, listeners)
-          if load_balancer = self.data[:load_balancers][lb_name]
-            response = Excon::Response.new
+          load_balancer = data[:load_balancers][lb_name]
+          raise Fog::AWS::ELB::NotFound unless load_balancer
+          response = Excon::Response.new
 
-            certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map { |_n, c| c['Arn'] }
 
-            listeners.each do |listener|
-              if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
-                raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
-              end
+          listeners.each do |listener|
+            if listener['SSLCertificateId'] && !certificate_ids.include?(listener['SSLCertificateId'])
+              raise Fog::AWS::IAM::NotFound, 'CertificateNotFound'
+            end
 
-              if (%w( HTTP HTTPS).include?(listener['Protocol']) && !%w( HTTP HTTPS ).include?(listener['InstanceProtocol'])) ||
-                  (%w( TCP SSL).include?(listener['Protocol']) && !%w( TCP SSL ).include?(listener['InstanceProtocol']))
-                raise Fog::AWS::ELB::ValidationError
-              end if listener['Protocol'] && listener['InstanceProtocol']
-              load_balancer['ListenerDescriptions'] << {'Listener' => listener, 'PolicyNames' => []}
+            if listener['Protocol'] && listener['InstanceProtocol']
+              if (
+                  %w[HTTP HTTPS].include?(listener['Protocol']) && !%w[HTTP HTTPS].include?(listener['InstanceProtocol'])
+              ) || (
+                %w[TCP SSL].include?(listener['Protocol']) && !%w[TCP SSL].include?(listener['InstanceProtocol'])
+              )
+              raise Fog::AWS::ELB::ValidationError
+              end
             end
+            load_balancer['ListenerDescriptions'] << { 'Listener' => listener, 'PolicyNames' => [] }
+          end
 
-            response.status = 200
-            response.body = {
-              'ResponseMetadata' => {
-                'RequestId' => Fog::AWS::Mock.request_id
-              }
+          response.status = 200
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
             }
+          }
 
-            response
-          else
-            raise Fog::AWS::ELB::NotFound
-          end
+          response
         end
       end
     end

data/lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb

@@ -35,7 +35,7 @@ module Fog
           raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
           instance_ids = [*instance_ids]
           instance_ids.each do |instance|
-            raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
+            raise Fog::AWS::ELB::InvalidInstance unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][instance]
           end
 
           response = Excon::Response.new

data/lib/fog/aws/requests/elb/describe_instance_health.rb

@@ -38,7 +38,7 @@ module Fog
           instance_ids = [*instance_ids]
           instance_ids = load_balancer['Instances'].map { |i| i['InstanceId'] } unless instance_ids.any?
           data = instance_ids.map do |id|
-            unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][id]
+            unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][id]
               raise Fog::AWS::ELB::InvalidInstance
             end
 

data/lib/fog/aws/requests/elb/describe_tags.rb

@@ -24,7 +24,7 @@ module Fog
         #   request({
         #     'Action'    => 'DescribeTags',
         #     :idempotent => true,
-        #     :parser     => Fog::Parsers::Compute::AWS::DescribeTags.new
+        #     :parser     => Fog::Parsers::AWS::Compute::DescribeTags.new
         #   }.merge!(params))
         # end
 

data/lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb

@@ -35,7 +35,7 @@ module Fog
           raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
           instance_ids = [*instance_ids]
           instances = instance_ids.map do |instance|
-            raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
+            raise Fog::AWS::ELB::InvalidInstance unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][instance]
             {'InstanceId' => instance}
           end
 

data/lib/fog/aws/requests/elbv2/add_tags.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/empty'
+
+        # adds tags to a load balancer instance
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_AddTags.html
+        # ==== Parameters
+        # * resource_arn <~String> - The Amazon Resource Name (ARN) of the resource
+        # * tags <~Hash> A Hash of (String) key-value pairs
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def add_tags(resource_arn, tags)
+          keys    = tags.keys.sort
+          values  = keys.map {|key| tags[key]}
+          request({
+              'Action'                     => 'AddTags',
+              'ResourceArns.member.1'      => resource_arn,
+              :parser                      => Fog::Parsers::AWS::ELBV2::Empty.new,
+            }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys))
+             .merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
+        end
+
+      end
+
+      class Mock
+        def add_tags(resource_arn, tags)
+          response = Excon::Response.new
+          if self.data[:load_balancers_v2][resource_arn]
+            self.data[:tags][resource_arn].merge! tags
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+            }
+            response
+          else
+            raise Fog::AWS::ELBV2::NotFound.new("Elastic load balancer #{resource_arn} not found")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/create_load_balancer.rb

@@ -0,0 +1,160 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/create_load_balancer'
+
+        # Create a new Elastic Load Balancer
+        #
+        # ==== Parameters
+        # * name<~String> - The name of the load balancer.
+        #                   This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens,
+        #                   must not begin or end with a hyphen, and must not begin with "internal-".
+        #                 - Required: Yes
+        # * options<~Hash>:
+        #   * ip_address_type<~String> - [Application Load Balancers] The type of IP addresses used by the subnets for your load balancer.
+        #                                The possible values are ipv4 (for IPv4 addresses) and dualstack (for IPv4 and IPv6 addresses).
+        #                                Internal load balancers must use ipv4.
+        #                              - Required: No
+        #   * scheme<~String> - The default is an Internet-facing load balancer. Valid Values: internet-facing | internal
+        #                     - Required: No
+        #   * security_groups<~Array> - The IDs of the security groups for the load balancer.
+        #                             - Required: No
+        #   * subnet_mappings<~Array> - The IDs of the public subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings.
+        #                             - [Application Load Balancers] You must specify subnets from at least two Availability Zones.
+        #                               You cannot specify Elastic IP addresses for your subnets.
+        #                             - [Network Load Balancers] You can specify subnets from one or more Availability Zones.
+        #                               You can specify one Elastic IP address per subnet if you need static IP addresses for your internet-facing load balancer.
+        #                               For internal load balancers, you can specify one private IP address per subnet from the IPv4 range of the subnet.
+        #                             - Required: No
+        #   * subnets<~Array> - The IDs of the public subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings.
+        #                     - [Application Load Balancers] You must specify subnets from at least two Availability Zones.
+        #                     - [Network Load Balancers] You can specify subnets from one or more Availability Zones.
+        #                     - Required: No
+        #   * tags<~Hash> - One or more tags to assign to the load balancer.
+        #                 - Required: No
+        #   * type<~String> - The type of load balancer. The default is application. Valid Values: application | network
+        #                   - Required: No
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'CreateLoadBalancerResult'<~Hash>:
+        #       * 'LoadBalancers'<~Array>
+        #         * 'AvailabilityZones'<~Array>:
+        #           * 'SubnetId'<~String> - ID of the subnet
+        #           * 'ZoneName'<~String> - Name of the Availability Zone
+        #           * 'LoadBalancerAddresses'<~Array>:
+        #             * 'IpAddress'<~String> - IP address
+        #             * 'AllocationId'<~String> - ID of the AWS allocation
+        #         * 'CanonicalHostedZoneName'<~String> - name of the Route 53 hosted zone associated with the load balancer
+        #         * 'CanonicalHostedZoneNameID'<~String> - ID of the Route 53 hosted zone associated with the load balancer
+        #         * 'CreatedTime'<~Time> - time load balancer was created
+        #         * 'DNSName'<~String> - external DNS name of load balancer
+        #         * 'LoadBalancerName'<~String> - name of load balancer
+        #         * 'SecurityGroups'<~Array> - array of security group id
+        def create_load_balancer(name, options = {})
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('Subnets.member.%d', options[:subnets]))
+          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups]))
+          params.merge!(Fog::AWS.serialize_keys('Scheme', options[:scheme]))
+          params.merge!(Fog::AWS.serialize_keys('Type', options[:type]))
+          params.merge!(Fog::AWS.serialize_keys('IpAddressType', options[:ip_address_type]))
+
+
+          unless options[:tags].nil?
+            tag_keys   = options[:tags].keys.sort
+            tag_values = tag_keys.map { |key| options[:tags][key] }
+            params.merge!(Fog::AWS.indexed_param('Tags.member.%d.Key', tag_keys))
+            params.merge!(Fog::AWS.indexed_param('Tags.member.%d.Value', tag_values))
+          end
+
+          unless options[:subnet_mappings].nil?
+            subnet_ids = []
+            allocation_ids = []
+            private_ipv4_address = []
+            options[:subnet_mappings].each do |subnet_mapping|
+              subnet_ids.push(subnet_mapping[:subnet_id])
+              allocation_ids.push(subnet_mapping[:allocation_id])
+              private_ipv4_address.push(subnet_mapping[:private_ipv4_address])
+            end
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.SubnetId', subnet_ids))
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.AllocationId', allocation_ids))
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.PrivateIPv4Address', private_ipv4_address))
+          end
+
+
+          request({
+            'Action'           => 'CreateLoadBalancer',
+            'Name' => name,
+            :parser            => Fog::Parsers::AWS::ELBV2::CreateLoadBalancer.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_load_balancer(name, options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          raise Fog::AWS::ELBV2::IdentifierTaken if self.data[:load_balancers_v2].key? name
+
+          dns_name = Fog::AWS::ELBV2::Mock.dns_name(name, @region)
+          type = options[:type] || 'application'
+          load_balancer_arn = Fog::AWS::Mock.arn('elasticloadbalancing', self.data[:owner_id], "loadbalancer/#{type[0..2]}/#{name}/#{Fog::AWS::Mock.key_id}")
+
+          subnet_ids = options[:subnets] || []
+          region = if subnet_ids.any?
+                     # using Hash here for Rubt 1.8.7 support.
+                     Hash[
+                       Fog::AWS::Compute::Mock.data.select do |_, region_data|
+                         unless region_data[@aws_access_key_id].nil?
+                           region_data[@aws_access_key_id][:subnets].any? do |region_subnets|
+                             subnet_ids.include? region_subnets['subnetId']
+                           end
+                         end
+                       end
+                     ].keys[0]
+                   else
+                     'us-east-1'
+                   end
+
+          subnets = Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
+          availability_zones = subnets.map do |subnet|
+            { "LoadBalancerAddresses"=>[], "SubnetId"=>subnet["subnetId"], "ZoneName"=>subnet["availabilityZone"]}
+          end
+          vpc_id = subnets.first['vpcId']
+
+          self.data[:tags] ||= {}
+          self.data[:tags][load_balancer_arn] = options[:tags] || {}
+
+          load_balancer = {
+            'AvailabilityZones' => availability_zones || [],
+            'Scheme' => options[:scheme] || 'internet-facing',
+            'SecurityGroups' => options[:security_groups] || [],
+            'CanonicalHostedZoneId' => '',
+            'CreatedTime' => Time.now,
+            'DNSName' => dns_name,
+            'VpcId' => vpc_id,
+            'Type' => type,
+            'State' => {'Code' => 'provisioning'},
+            'LoadBalancerArn' => load_balancer_arn,
+            'LoadBalancerName' => name
+          }
+          self.data[:load_balancers_v2][load_balancer_arn] = load_balancer
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'CreateLoadBalancerResult' => {
+              'LoadBalancers' => [load_balancer]
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/describe_listeners.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_listeners'
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * 'LoadBalancerArn'<~String> - The Amazon Resource Name (ARN) of the load balancer
+        # * options<~Hash>
+        #   * 'Marker'<String> - Indicates where to begin in your list of load balancers
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeListenersResult'<~Hash>:
+        #       * 'Listeners'<~Array>
+        #         * 'LoadBalancerArn'<~String> - The Amazon Resource Name (ARN) of the load balancer
+        #         * 'Protocol'<~String> - The protocol for connections from clients to the load balancer
+        #         * 'Port'<~String> - The port on which the load balancer is listening
+        #         * 'DefaultActions'<~Array> - The default actions for the listener
+        #           * 'Type'<~String> - The type of action
+        #           * 'TargetGroupArn'<~String> - The Amazon Resource Name (ARN) of the target group. Specify only when Type is forward
+        #       * 'NextMarker'<~String> - Marker to specify for next page
+        def describe_listeners(load_balancer_arn, options = {})
+          request({
+            'Action'  => 'DescribeListeners',
+            'LoadBalancerArn' => load_balancer_arn,
+            :parser   => Fog::Parsers::AWS::ELBV2::DescribeListeners.new
+          }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/describe_load_balancers.rb

@@ -0,0 +1,100 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_load_balancers'
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * options<~Hash>
+        #   * 'LoadBalancerNames'<~Array> - List of load balancer names to describe, defaults to all
+        #   * 'Marker'<String> - Indicates where to begin in your list of load balancers
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancersResult'<~Hash>:
+        #       * 'LoadBalancers'<~Array>
+        #         * 'AvailabilityZones'<~Array>:
+        #           * 'SubnetId'<~String> - ID of the subnet
+        #           * 'ZoneName'<~String> - Name of the Availability Zone
+        #           * 'LoadBalancerAddresses'<~Array>:
+        #             * 'IpAddress'<~String> - IP address
+        #             * 'AllocationId'<~String> - ID of the AWS allocation
+        #         * 'CanonicalHostedZoneName'<~String> - name of the Route 53 hosted zone associated with the load balancer
+        #         * 'CanonicalHostedZoneNameID'<~String> - ID of the Route 53 hosted zone associated with the load balancer
+        #         * 'CreatedTime'<~Time> - time load balancer was created
+        #         * 'DNSName'<~String> - external DNS name of load balancer
+        #         * 'LoadBalancerName'<~String> - name of load balancer
+        #         * 'SecurityGroups'<~Array> - array of security group id
+        #         * 'NextMarker'<~String> - Marker to specify for next page
+        def describe_load_balancers(options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
+            options = { 'LoadBalancerNames' => [options].flatten }
+          end
+
+          if names = options.delete('LoadBalancerNames')
+            options.update(Fog::AWS.indexed_param('LoadBalancerNames.member', [*names]))
+          end
+
+          request({
+            'Action'  => 'DescribeLoadBalancers',
+            :parser   => Fog::Parsers::AWS::ELBV2::DescribeLoadBalancers.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def describe_load_balancers(options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
+            options = { 'LoadBalancerNames' => [options].flatten }
+          end
+
+          lb_names = options['LoadBalancerNames'] || []
+
+          lb_names = [*lb_names]
+          load_balancers = if lb_names.any?
+            lb_names.map do |lb_name|
+              lb = self.data[:load_balancers_v2].find { |name, data| name == lb_name }
+              raise Fog::AWS::ELBV2::NotFound unless lb
+              lb[1].dup
+            end.compact
+          else
+            self.data[:load_balancers_v2].map { |lb, values| values.dup }
+          end
+
+          marker = options.fetch('Marker', 0).to_i
+          if load_balancers.count - marker > 400
+            next_marker = marker + 400
+            load_balancers = load_balancers[marker...next_marker]
+          else
+            next_marker = nil
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancersResult' => {
+              'LoadBalancers' => load_balancers
+            }
+          }
+
+          if next_marker
+            response.body['DescribeLoadBalancersResult']['NextMarker'] = next_marker.to_s
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/describe_tags.rb

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_tags'
+
+        # returns a Hash of tags for a load balancer
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DescribeTags.html
+        # ==== Parameters
+        # * resource_arns <~Array> - ARN(s) of the ELB instance whose tags are to be retrieved
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_tags(resource_arns)
+          request({
+              'Action' => 'DescribeTags',
+              :parser  => Fog::Parsers::AWS::ELBV2::DescribeTags.new
+            }.merge!(Fog::AWS.indexed_param('ResourceArns.member.%d', [*resource_arns]))
+          )
+        end
+      end
+
+      class Mock
+        def describe_tags(resource_arns)
+          response = Excon::Response.new
+          resource_arns = [*resource_arns]
+
+          tag_describtions = resource_arns.map do |resource_arn|
+            if self.data[:load_balancers_v2][resource_arn]
+              {
+                "Tags"=>self.data[:tags][resource_arn],
+                "ResourceArn"=>resource_arn
+              }
+            else
+              raise Fog::AWS::ELBV2::NotFound.new("Elastic load balancer #{resource_arns} not found")
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{"RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeTagsResult"=>{"TagDescriptions"=> tag_describtions}
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/remove_tags.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/empty'
+
+        # removes tags from an elastic load balancer instance
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_RemoveTags.html
+        # ==== Parameters
+        # * resource_arn <~String> - ARN of the ELB instance whose tags are to be retrieved
+        # * keys <~Array> A list of String keys for the tags to remove
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def remove_tags(resource_arn, keys)
+          request(
+            { 'Action'                      => 'RemoveTags',
+              'ResourceArns.member.1'  => resource_arn,
+              :parser => Fog::Parsers::AWS::ELBV2::Empty.new,
+            }.merge(Fog::AWS.indexed_param('TagKeys.member.%d', keys))
+          )
+        end
+
+      end
+
+      class Mock
+
+        def remove_tags(resource_arn, keys)
+          response = Excon::Response.new
+          if self.data[:load_balancers_v2][resource_arn]
+            keys.each {|key| self.data[:tags][resource_arn].delete key}
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+            }
+            response
+          else
+            raise Fog::AWS::ELBV2::NotFound.new("Elastic load balancer #{resource_arn} not found")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/add_role_to_instance_profile.rb

@@ -27,6 +27,25 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def add_role_to_instance_profile(role_name, instance_profile_name)
+          response = Excon::Response.new
+
+          unless profile = self.data[:instance_profiles][instance_profile_name]
+            raise Fog::AWS::IAM::NotFound.new("Instance Profile #{instance_profile_name} cannot be found.")
+          end
+
+          unless role = self.data[:roles][role_name]
+            raise Fog::AWS::IAM::NotFound.new("Role #{role_name} cannot be found.")
+          end
+
+          profile["Roles"] << role_name
+
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end