fog 1.1.1 → 1.2.0

data/lib/fog/aws/requests/elasticache/create_cache_cluster.rb

@@ -36,14 +36,14 @@ module Fog
           # Merge the Cache Security Group parameters with the normal options
           request(sec_group_params.merge(
             'Action'          => 'CreateCacheCluster',
-            'CacheClusterId'  => id,
+            'CacheClusterId'  => id.strip,
             'CacheNodeType'   => options[:node_type]  || 'cache.m1.large',
             'Engine'          => options[:engine]     || 'memcached',
             'NumCacheNodes'   => options[:num_nodes]  || 1,
             'AutoMinorVersionUpgrade'     => options[:auto_minor_version_upgrade],
             'CacheParameterGroupName'     => options[:parameter_group_name],
             'EngineVersion'               => options[:engine_version],
-            'NotificationTopicArn'        => options[:notification_topic_arn],
+            'NotificationTopicArn'        => (options[:notification_topic_arn]).strip,
             'Port'                        => options[:port],
             'PreferredAvailabilityZone'   => options[:preferred_availablility_zone],
             'PreferredMaintenanceWindow'  => options[:preferred_maintenance_window],

data/lib/fog/aws/requests/elasticache/modify_cache_cluster.rb

@@ -45,13 +45,13 @@ module Fog
           # Merge the Cache Security Group parameters with the normal options
           request(node_id_params.merge(sec_group_params.merge(
             'Action'                      => 'ModifyCacheCluster',
-            'CacheClusterId'              => id,
+            'CacheClusterId'              => id.strip,
             'ApplyImmediately'            => options[:apply_immediately],
             'NumCacheNodes'               => options[:num_nodes],
             'AutoMinorVersionUpgrade'     => options[:auto_minor_version_upgrade],
             'CacheParameterGroupName'     => options[:parameter_group_name],
             'EngineVersion'               => options[:engine_version],
-            'NotificationTopicArn'        => options[:notification_topic_arn],
+            'NotificationTopicArn'        => (options[:notification_topic_arn]).strip,
             'NotificationTopicStatus'     => options[:notification_topic_status],
             'PreferredMaintenanceWindow'  => options[:preferred_maintenance_window],
             :parser => Fog::Parsers::AWS::Elasticache::SingleCacheCluster.new

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

@@ -37,6 +37,8 @@ module Fog
 
             load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
 
+            create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
+
             response.body = {
               'ResponseMetadata' => {
                 'RequestId' => Fog::AWS::Mock.request_id

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

@@ -37,7 +37,9 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'PolicyName' => policy_name, 'CookieExpirationPeriod' => cookie_expiration_period }
+            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'CookieExpirationPeriod' => cookie_expiration_period, 'PolicyName' => policy_name }
+
+            create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
 
             response.body = {
               'ResponseMetadata' => {

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

@@ -11,9 +11,10 @@ module Fog
         # * availability_zones<~Array> - List of availability zones for the ELB
         # * lb_name<~String> - Name for the new ELB -- must be unique
         # * listeners<~Array> - Array of Hashes describing ELB listeners to assign to the ELB
-        #   * 'Protocol'<~String> - Protocol to use. Either HTTP or TCP.
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP, HTTPS, TCP or SSL.
         #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
         #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        #   * 'InstanceProtocol'<~String> - Protocol for sending traffic to an instance. Either HTTP, HTTPS, TCP or SSL.
         #   * 'SSLCertificateId'<~String> - ARN of the server certificate
         # ==== Returns
         # * response<~Excon::Response>:
@@ -28,17 +29,20 @@ module Fog
           listener_protocol = []
           listener_lb_port = []
           listener_instance_port = []
+          listener_instance_protocol = []
           listener_ssl_certificate_id = []
           listeners.each do |listener|
             listener_protocol.push(listener['Protocol'])
             listener_lb_port.push(listener['LoadBalancerPort'])
             listener_instance_port.push(listener['InstancePort'])
+            listener_instance_protocol.push(listener['InstanceProtocol'])
             listener_ssl_certificate_id.push(listener['SSLCertificateId'])
           end
 
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstanceProtocol', listener_instance_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.SSLCertificateId', listener_ssl_certificate_id))
 
           request({
@@ -83,8 +87,9 @@ module Fog
             'ListenerDescriptions' => listeners,
             'LoadBalancerName' => lb_name,
             'Policies' => {
+              'AppCookieStickinessPolicies' => [],
               'LBCookieStickinessPolicies' => [],
-              'AppCookieStickinessPolicies' => []
+              'Proper' => []
             },
             'SourceSecurityGroup' => {
               'GroupName' => '',

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

@@ -10,9 +10,10 @@ module Fog
         # ==== Parameters
         # * lb_name<~String> - Name for the new ELB -- must be unique
         # * listeners<~Array> - Array of Hashes describing ELB listeners to add to the ELB
-        #   * 'Protocol'<~String> - Protocol to use. Either HTTP or TCP.
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP, HTTPS, TCP or SSL.
         #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
         #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        #   * 'InstanceProtocol'<~String> - Protocol for sending traffic to an instance. Either HTTP, HTTPS, TCP or SSL.
         #   * 'SSLCertificateId'<~String> - ARN of the server certificate
         # ==== Returns
         # * response<~Excon::Response>:
@@ -25,17 +26,20 @@ module Fog
           listener_protocol = []
           listener_lb_port = []
           listener_instance_port = []
+          listener_instance_protocol = []
           listener_ssl_certificate_id = []
           listeners.each do |listener|
             listener_protocol.push(listener['Protocol'])
             listener_lb_port.push(listener['LoadBalancerPort'])
             listener_instance_port.push(listener['InstancePort'])
+            listener_instance_protocol.push(listener['InstanceProtocol'])
             listener_ssl_certificate_id.push(listener['SSLCertificateId'])
           end
 
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstanceProtocol', listener_instance_protocol))
           params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.SSLCertificateId', listener_ssl_certificate_id))
 
           request({
@@ -58,6 +62,11 @@ module Fog
               if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
                 raise Fog::AWS::IAM::NotFound.new('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' => []}
             end
 

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

@@ -0,0 +1,79 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+        # Create Elastic Load Balancer Policy
+        #
+        # ==== Parameters
+        # * lb_name<~String> - The name associated with the LoadBalancer for which the policy is being created. This name must be unique within the client AWS account.
+        # * attributes<~Hash> - A list of attributes associated with the policy being created.
+        #   * 'AttributeName'<~String> - The name of the attribute associated with the policy.
+        #   * 'AttributeValue'<~String> - The value of the attribute associated with the policy.
+        # * name<~String> - The name of the LoadBalancer policy being created. The name must be unique within the set of policies for this LoadBalancer.
+        # * type_name<~String> - The name of the base policy type being used to create this policy. To get the list of policy types, use the DescribeLoadBalancerPolicyTypes action.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
+          params = {}
+
+          attribute_name = []
+          attribute_value = []
+          attributes.each do |name, value|
+            attribute_name.push(name)
+            attribute_value.push(value)
+          end
+
+          params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeName', attribute_name))
+          params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeValue', attribute_value))
+
+          request({
+            'Action'           => 'CreateLoadBalancerPolicy',
+            'LoadBalancerName' => lb_name,
+            'PolicyName'       => name,
+            'PolicyTypeName'   => type_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+        def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
+          if load_balancer = self.data[:load_balancers][lb_name]
+            raise Fog::AWS::IAM::DuplicatePolicyName if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
+            raise Fog::AWS::IAM::PolicyTypeNotFound unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
+
+            response = Excon::Response.new
+
+            attributes = attributes.map do |key, value|
+              {"AttributeName" => key, "AttributeValue" => value.to_s}
+            end
+
+            load_balancer['Policies']['Proper'] << {
+              'PolicyAttributeDescriptions' => attributes,
+              'PolicyName' => name,
+              'PolicyTypeName' => type_name
+            }
+
+            response.status = 200
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module Fog
             response.status = 200
 
             load_balancer['Policies'].each do |name, policies|
-              policies.delete_if { |p| p['PolicyName'] == policy_name }
+              policies.delete_if { |policy| policy['PolicyName'] == policy_name }
             end
 
             response.body = {

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

@@ -0,0 +1,71 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_load_balancer_policies'
+
+        # Describe all or specified load balancer policies
+        #
+        # ==== Parameters
+        # * lb_name<~String> - The mnemonic name associated with the LoadBalancer. If no name is specified, the operation returns the attributes of either all the sample policies pre-defined by Elastic Load Balancing or the specified sample polices.
+        # * names<~Array> - The names of LoadBalancer policies you've created or Elastic Load Balancing sample policy names.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancerPoliciesResult'<~Hash>:
+        #       * 'PolicyDescriptions'<~Array>
+        #         * 'PolicyAttributeDescriptions'<~Array>
+        #           * 'AttributeName'<~String> - The name of the attribute associated with the policy.
+        #           * 'AttributeValue'<~String> - The value of the attribute associated with the policy.
+        #         * 'PolicyName'<~String> - The name mof the policy associated with the LoadBalancer.
+        #         * 'PolicyTypeName'<~String> - The name of the policy type.
+        def describe_load_balancer_policies(lb_name = nil, names = [])
+          params = Fog::AWS.indexed_param('PolicyNames.member', [*names])
+          request({
+            'Action'  => 'DescribeLoadBalancerPolicies',
+            'LoadBalancerName' => lb_name,
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancerPolicies.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+        def describe_load_balancer_policies(lb_name = nil, names = [])
+          if lb_name
+            raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+            names = [*names]
+            policies = if names.any?
+              names.map do |name|
+                raise Fog::AWS::ELB::PolicyNotFound unless policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
+                policy.dup
+              end.compact
+            else
+              load_balancer['Policies']['Proper']
+            end
+          else
+            policies = []
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancerPoliciesResult' => {
+              'PolicyDescriptions' => policies
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_load_balancer_policy_types'
+
+        # Describe all or specified load balancer policy types
+        #
+        # ==== Parameters
+        # * type_name<~Array> - Specifies the name of the policy types. If no names are specified, returns the description of all the policy types defined by Elastic Load Balancing service.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancerPolicyTypesResult'<~Hash>:
+        #       * 'PolicyTypeDescriptions'<~Array>
+        #         * 'Description'<~String> - A human-readable description of the policy type.
+        #         * 'PolicyAttributeTypeDescriptions'<~Array>
+        #           * 'AttributeName'<~String> - The name of the attribute associated with the policy type.
+        #           * 'AttributeValue'<~String> - The type of attribute. For example, Boolean, Integer, etc.
+        #           * 'Cardinality'<~String> - The cardinality of the attribute.
+        #           * 'DefaultValue'<~String> - The default value of the attribute, if applicable.
+        #           * 'Description'<~String> - A human-readable description of the attribute.
+        #         * 'PolicyTypeName'<~String> - The name of the policy type.
+        def describe_load_balancer_policy_types(type_names = [])
+          params = Fog::AWS.indexed_param('PolicyTypeNames.member', [*type_names])
+          request({
+            'Action'  => 'DescribeLoadBalancerPolicyTypes',
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancerPolicyTypes.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+        def describe_load_balancer_policy_types(type_names = [])
+          type_names = [*type_names]
+          policy_types = if type_names.any?
+            type_names.map do |type_name|
+              policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
+              raise Fog::AWS::ELB::PolicyTypeNotFound unless policy_type
+              policy_type[1].dup
+            end.compact
+          else
+            self.data[:policy_types].map { |policy_type| policy_type.dup }
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancerPolicyTypesResult' => {
+              'PolicyTypeDescriptions' => policy_types
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -73,7 +73,11 @@ module Fog
               'RequestId' => Fog::AWS::Mock.request_id
             },
             'DescribeLoadBalancersResult' => {
-              'LoadBalancerDescriptions' => load_balancers.map { |lb| lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }; lb }
+              'LoadBalancerDescriptions' => load_balancers.map do |lb|
+                lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }
+                lb['Policies'] = lb['Policies'].reject { |name, policies| name == 'Proper' }
+                lb
+              end
             }
           }
 

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

@@ -34,6 +34,33 @@ module Fog
       end
 
       class Mock
+        def set_load_balancer_listener_ssl_certificate(lb_name, load_balancer_port, ssl_certificate_id)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
+          if !certificate_ids.include? ssl_certificate_id
+            raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
+          end
+
+          response = Excon::Response.new
+
+          unless listener = load_balancer['ListenerDescriptions'].find { |listener| listener['Listener']['LoadBalancerPort'] == load_balancer_port }
+            response.status = 400
+            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>ListenerNotFound</Code><Message>LoadBalancer does not have a listnener configured at the given port.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
+            raise Excon::Errors.status_error({:expects => 200}, response)
+          end
+
+          listener['Listener']['SSLCertificateId'] = ssl_certificate_id
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata" => {
+              "RequestId" => Fog::AWS::Mock.request_id
+            }
+          }
+
+          response
+        end
       end
     end
   end

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

@@ -57,7 +57,7 @@ module Fog
             raise Excon::Errors.status_error({:expects => 200}, response)
           end
 
-          unless load_balancer['Policies'].find { |name, policies| policies.find { |policy| policy['PolicyName'] == policy_names.first } }
+          unless load_balancer['Policies']['Proper'].find { |policy| policy['PolicyName'] == policy_names.first }
             response.status = 400
             response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>PolicyNotFound</Code><Message>One or more specified policies were not found.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
             raise Excon::Errors.status_error({:expects => 200}, response)

data/lib/fog/aws/requests/emr/run_job_flow.rb

@@ -77,13 +77,15 @@ module Fog
               'Args' => ['s3://us-east-1.elasticmapreduce/libs/hive/hive-script', '--base-path', 's3://us-east-1.elasticmapreduce/libs/hive/', '--install-hive']},
             'ActionOnFailure' => 'TERMINATE_JOB_FLOW'
           }
-          steps << {
-            'Name' => 'Install Hive Site Configuration',
-            'HadoopJarStep' => {
-              'Jar' => 's3://us-east-1.elasticmapreduce/libs/script-runner/script-runner.jar',
-              'Args' => ['s3://us-east-1.elasticmapreduce/libs/hive/hive-script', '--base-path',  's3://us-east-1.elasticmapreduce/libs/hive/', '--install-hive-site', '--hive-site=s3://raybeam.okl/prod/hive/hive-site.xml']},
-            'ActionOnFailure' => 'TERMINATE_JOB_FLOW'
-          }
+          
+          # To add a configuration step to the Hive flow, see the step below
+          # steps << {
+          #   'Name' => 'Install Hive Site Configuration',
+          #   'HadoopJarStep' => {
+          #     'Jar' => 's3://us-east-1.elasticmapreduce/libs/script-runner/script-runner.jar',
+          #     'Args' => ['s3://us-east-1.elasticmapreduce/libs/hive/hive-script', '--base-path',  's3://us-east-1.elasticmapreduce/libs/hive/', '--install-hive-site', '--hive-site=s3://my.bucket/hive/hive-site.xml']},
+          #   'ActionOnFailure' => 'TERMINATE_JOB_FLOW'
+          # }
           options['Steps'] = steps
           
           if not options['Instances'].nil?

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

@@ -29,6 +29,30 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def add_user_to_group(group_name, user_name)
+          if data[:groups].has_key? group_name
+            if data[:users].has_key? user_name
+
+              unless data[:groups][group_name][:members].include?(user_name)
+                data[:groups][group_name][:members] << user_name
+              end
+
+              Excon::Response.new.tap do |response|
+                response.status = 200
+                response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              end
+            else
+              raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+        end
+
+      end
     end
   end
 end

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

@@ -32,6 +32,30 @@ module Fog
         end
 
       end
+      class Mock
+        def create_access_key(options)
+          #FIXME: Not 100% correct as AWS will use the signing credentials when there is no 'UserName' in the options hash
+          #       Also doesn't raise an error when there are too many keys
+          user_name = options['UserName']
+          if data[:users].has_key? user_name
+            key = { 'SecretAccessKey' => Fog::Mock.random_base64(40),
+                    'Status' => 'Active',
+                    'AccessKeyId' => Fog::AWS::Mock.key_id(20),
+                    'UserName' => user_name
+                  }
+
+            data[:users][user_name][:access_keys] << key
+
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.body = { 'AccessKey' => key,
+                                'RequestId' => Fog::AWS::Mock.request_id } 
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new('The user with name booboboboob cannot be found.')
+          end
+        end
+      end
     end
   end
 end

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

@@ -34,6 +34,27 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def create_group(group_name, path = '/')
+          if data[:groups].has_key? group_name
+            raise Fog::AWS::IAM::EntityAlreadyExists.new("Group with name #{group_name} already exists.")
+          else
+            data[:groups][group_name][:path] = path
+            Excon::Response.new.tap do |response|
+              response.body = { 'Group' => {
+                                             'GroupId'   => (data[:groups][group_name][:group_id]).strip,
+                                             'GroupName' => group_name,
+                                             'Path'      => path,
+                                             'Arn'       => (data[:groups][group_name][:arn]).strip },
+                                'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          end
+
+        end
+      end
     end
   end
 end

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

@@ -34,6 +34,27 @@ module Fog
         end
 
       end
+
+      class Mock
+        def create_user(user_name, path='/')
+          if data[:users].has_key? user_name
+            raise Fog::AWS::IAM::EntityAlreadyExists.new "User with name #{user_name} already exists."
+          else
+            data[:users][user_name][:path] = path
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.body = { 'User' => {
+                                           "UserId"   => data[:users][user_name][:user_id],
+                                           "Path"     => path,
+                                           "UserName" => user_name,
+                                           "Arn"      => (data[:users][user_name][:arn]).strip
+                                           },
+                                'RequestId' => Fog::AWS::Mock.request_id
+                               }
+            end
+          end
+        end
+      end
     end
   end
 end

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

@@ -29,6 +29,23 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def delete_access_key(access_key_id, options = {})
+          user_name = options['UserName']
+          if user_name && data[:users].has_key?(user_name) && data[:users][user_name][:access_keys].any? { |akey| akey['AccessKeyId'] == access_key_id }
+            data[:users][user_name][:access_keys].delete_if { |akey| akey['AccessKeyId'] == access_key_id }
+            Excon::Response.new.tap do |response|
+              response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The Access Key with id #{access_key_id} cannot be found.")
+          end
+        end
+
+      end
     end
   end
 end

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

@@ -27,6 +27,25 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def delete_group(group_name)
+          if data[:groups].has_key? group_name
+            if data[:groups][group_name][:members].empty?
+              data[:groups].delete group_name
+              Excon::Response.new.tap do |response|
+                response.status = 200
+                response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              end
+            else
+              raise Fog::AWS::IAM::Error.new("DeleteConflict => Cannot delete entity, must delete users in group first.")
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

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

@@ -27,6 +27,23 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def delete_user(user_name)
+          if data[:users].has_key? user_name
+            data[:users].delete user_name
+            Excon::Response.new.tap do |response|
+              response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+
+        end
+
+      end
     end
   end
 end