fog-maestrodev 1.19.0.20140212012611 → 1.20.0.20140305101305

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

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class Elasticache
+      class Real
+
+        require 'fog/aws/parsers/elasticache/create_cache_subnet_group'
+
+        # Creates a cache subnet group
+        # http://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheSubnetGroup.html
+        #
+        # ==== Parameters
+        # * CacheSubnetGroupName <~String> - A name for the cache subnet group. This value is stored as a lowercase string. Must contain no more than 255 alphanumeric characters or hyphens.
+        # * SubnetIds <~Array> - The VPC subnet IDs for the cache subnet group.
+        # * CacheSubnetGroupDescription <~String> - A description for the cache subnet group.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def create_cache_subnet_group(name, subnet_ids, description = name)
+          params = { 
+            'Action' => 'CreateCacheSubnetGroup',
+            'CacheSubnetGroupName' => name,
+            'CacheSubnetGroupDescription' => description,
+            :parser => Fog::Parsers::AWS::Elasticache::CreateCacheSubnetGroup.new 
+          }
+          params.merge!(Fog::AWS.indexed_param("SubnetIds.member", Array(subnet_ids)))
+          request(params)
+        end
+
+      end
+
+      class Mock
+
+        def create_cache_subnet_group(name, subnet_ids, description = name)
+          response = Excon::Response.new
+          if self.data[:subnet_groups] && self.data[:subnet_groups][name]
+            raise Fog::AWS::Elasticache::IdentifierTaken.new("CacheSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
+          end
+
+          collection = Fog::Compute[:aws]
+          collection.region = @region
+          subnets = collection.subnets
+
+          subnets = subnet_ids.map { |snid| subnets.get(snid) }
+          vpc_id = subnets.first.vpc_id
+
+          data = {
+            'CacheSubnetGroupName' => name,
+            'CacheSubnetGroupDescription' => description,
+            'SubnetGroupStatus' => 'Complete',
+            'Subnets' => subnet_ids,
+            'VpcId' => vpc_id
+          }
+          self.data[:subnet_groups][name] = data
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            'CreateCacheSubnetGroupResult' => { 'CacheSubnetGroup' => data }
+          }
+          response
+
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,40 @@
+module Fog
+  module AWS
+    class Elasticache
+      class Real
+
+        require 'fog/aws/parsers/elasticache/base'
+
+        # deletes a cache subnet group
+        #
+        # === Parameters
+        # * name <~String> - The name for the Cache Subnet Group
+        # === Returns
+        # * response <~Excon::Response>:
+        #   * body <~Hash>
+        def delete_cache_subnet_group(name)
+          request({
+            'Action' => 'DeleteCacheSubnetGroup',
+            'CacheSubnetGroupName' => name,
+            :parser => Fog::Parsers::AWS::Elasticache::Base.new
+          })
+        end
+      end
+
+      class Mock
+        def delete_cache_subnet_group(name)
+          if self.data[:subnet_groups].delete(name)
+            Excon::Response.new(
+                {
+                    :status => 200,
+                    :body =>   { 'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id } }
+                }
+            )
+          else
+            raise Fog::AWS::Elasticache::NotFound.new("CacheSubnetGroupNotFound => #{name} not found")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class Elasticache
+      class Real
+
+        require 'fog/aws/parsers/elasticache/describe_cache_subnet_groups'
+
+        # This API returns a list of CacheSubnetGroup descriptions. If a CacheSubnetGroupName is specified, the list will contain only
+        # the descriptions of the specified CacheSubnetGroup
+        # http://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheSubnetGroups.html
+        # ==== Parameters
+        # * CacheSubnetGroupName <~String> - The name of a specific database subnet group to return details for.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_cache_subnet_groups(name = nil, opts = {})
+          params = {}
+          if opts[:marker]
+            params['Marker'] = opts[:marker]
+          end
+          if name
+            params['CacheSubnetGroupName'] = name
+          end
+          if opts[:max_records]
+            params['MaxRecords'] = opts[:max_records]
+          end
+
+          request({
+            'Action'  => 'DescribeCacheSubnetGroups',
+            :parser   => Fog::Parsers::AWS::Elasticache::DescribeCacheSubnetGroups.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_cache_subnet_groups(name = nil, opts = {})
+          response = Excon::Response.new
+
+          subnet_group_set = []
+          if name
+            if subnet_group = self.data[:subnet_groups][name]
+              subnet_group_set << subnet_group
+            else
+              raise Fog::AWS::Elasticache::NotFound.new("Subnet Group #{name} not found")
+            end
+          else
+            subnet_group_set = self.data[:subnet_groups].values
+          end
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeCacheSubnetGroupsResult" => { "CacheSubnetGroups" => subnet_group_set }
+          }
+          response
+        end
+      end
+
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module Fog
           params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
           params.merge!(Fog::AWS.indexed_param('Subnets.member.%d', options[:subnet_ids]))
           params.merge!(Fog::AWS.serialize_keys('Scheme', options[:scheme]))
-          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups])) 
+          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups]))
 
           listener_protocol = []
           listener_lb_port = []
@@ -74,7 +74,8 @@ module Fog
 
           dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
 
-          region = availability_zones ? availability_zones.first.gsub(/[a-z]$/, '') : "us-east-1"
+          availability_zones = [*availability_zones].compact
+          region = availability_zones.empty? ? "us-east-1" : availability_zones.first.gsub(/[a-z]$/, '')
           supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].detect { |h| h["attributeName"] == "supported-platforms" }["values"]
           security_group = if supported_platforms.include?("EC2")
                              Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']

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

@@ -36,7 +36,9 @@ module Fog
             'RequestId' => Fog::AWS::Mock.request_id
           }
 
-          self.data[:server_certificates].delete(server_certificate_name)
+          unless self.data[:server_certificates].delete(server_certificate_name)
+            raise Fog::AWS::IAM::NotFound.new("The Server Certificate with name #{server_certificate_name} cannot be found.")
+          end
 
           response
         end

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

@@ -18,6 +18,7 @@ module Fog
         # @param DBSecurityGroups [Array] A list of DB Security Groups to authorize on this DB Instance
         # @param Engine [String] The name of the database engine to be used for this instance.
         # @param EngineVersion [String] The version number of the database engine to use.
+        # @param Iops [Integer] IOPS rate
         # @param MasterUsername [String] The db master user
         # @param MasterUserPassword [String] The new password for the DB Instance master user
         # @param MultiAZ [Boolean] Specifies if the DB Instance is a Multi-AZ deployment
@@ -98,6 +99,7 @@ module Fog
                  "DBInstanceStatus"=>"creating",
                  "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
                  "AllocatedStorage"=> options["AllocatedStorage"],
+                 "Iops" => options["Iops"],
                  "DBParameterGroups"=> # I think groups should be in the self.data method
                           [{"DBParameterGroupName"=>"default.mysql5.5",
                             "ParameterApplyStatus"=>"in-sync"}],

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

@@ -51,6 +51,7 @@ module Fog
             'Engine' => source['Engine'],
             'EngineVersion' => options['EngineVersion'] || '5.5.12',
             'InstanceCreateTime' => nil,
+            'Iops' => source['Iops'],
             'LatestRestorableTime' => nil,
             'LicenseModel' => 'general-public-license',
             'MasterUsername' => source['MasterUsername'],

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

@@ -47,7 +47,7 @@ module Fog
             'InstanceCreateTime'   => Time.now
           }
           # Copy attributes from server
-          %w(Engine EngineVersion AvailabilityZone AllocatedStorage MasterUsername InstanceCreateTime).each do |key|
+          %w(Engine EngineVersion AvailabilityZone AllocatedStorage Iops MasterUsername InstanceCreateTime).each do |key|
             snapshot_data[key] = server_data[key]
           end
           snapshot_data['Port'] = server_data['Endpoint']['Port']

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

@@ -35,6 +35,8 @@ module Fog
 
           # collection = Fog::Compute::AWS.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
           collection = Fog::Compute[:aws]
+          collection.region = @region
+
           subnets = subnet_ids.map do |snid|
             subnet = collection.subnets.get(snid)
             raise Fog::AWS::RDS::NotFound.new("InvalidSubnet => The subnet '#{snid}' was not found") if subnet.nil?

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

@@ -19,6 +19,7 @@ module Fog
         # * DBParameterGroupName <~String> The name of the DB Parameter Group to apply to this DB Instance  
         # * DBSecurityGroups <~Array> A list of DB Security Groups to authorize on this DB Instance 
         # * EngineVersion <~String> The version number of the database engine to upgrade to.
+        # * Iops <~Integer> IOPS rate
         # * MasterUserPassword  <~String> The new password for the DB Instance master user
         # * MultiAZ <~Boolean> Specifies if the DB Instance is a Multi-AZ deployment
         # * PreferredBackupWindow <~String> The daily time range during which automated backups are created if automated backups are enabled

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

@@ -23,6 +23,24 @@ module Fog
         end
 
       end # Real
+
+      class Mock # :nodoc:all
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
+
+        def abort_multipart_upload(bucket_name, object_name, upload_id)
+          verify_mock_bucket_exists(bucket_name)
+          upload_info = get_upload_info(bucket_name, upload_id, true)
+          response = Excon::Response.new
+          if upload_info
+            response.status = 204
+            response
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          end
+        end
+      end # Mock
     end # Storage
   end # AWS
 end # Fog

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

@@ -47,6 +47,29 @@ module Fog
         end
 
       end # Real
+
+      class Mock # :nodoc:all
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
+
+        def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
+          bucket = verify_mock_bucket_exists(bucket_name)
+          upload_info = get_upload_info(bucket_name, upload_id, true)
+          body = parts.map { |pid| upload_info[:parts][pid.to_i] }.join
+          object = store_mock_object(bucket, object_name, body, upload_info[:options])
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'Location' => "http://#{bucket_name}.s3.amazonaws.com/#{object_name}",
+            'Bucket'   => bucket_name,
+            'Key'      => object_name,
+            'ETag'     => object['ETag'],
+          }
+          response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
+          response
+        end
+      end # Mock
     end # Storage
   end # AWS
 end # Fog

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

@@ -39,6 +39,30 @@ module Fog
         end
 
       end # Real
+
+      class Mock # :nodoc:all
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
+
+        def initiate_multipart_upload(bucket_name, object_name, options = {})
+          verify_mock_bucket_exists(bucket_name)
+          upload_id = UUID.uuid
+          self.data[:multipart_uploads][bucket_name] ||= {}
+          self.data[:multipart_uploads][bucket_name][upload_id] = {
+            :parts => {},
+            :options => options,
+          }
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "Bucket" => bucket_name,
+            "Key" => object_name,
+            "UploadId" => upload_id,
+          }
+          response
+        end
+      end # Mock
     end # Storage
   end # AWS
 end # Fog

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

@@ -44,66 +44,30 @@ module Fog
 
       class Mock # :nodoc:all
 
-        def put_object(bucket_name, object_name, data, options = {})
-          acl = options['x-amz-acl'] || 'private'
-          if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
-            raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
-          else
-            self.data[:acls][:object][bucket_name] ||= {}
-            self.data[:acls][:object][bucket_name][object_name] = self.class.acls(acl)
-          end
-
-          data = Fog::Storage.parse_data(data)
-          unless data[:body].is_a?(String)
-            data[:body] = data[:body].read
-          end
-          response = Excon::Response.new
-          if (bucket = self.data[:buckets][bucket_name])
-            response.status = 200
-            object = {
-              :body             => data[:body],
-              'Content-Type'    => options['Content-Type'] || data[:headers]['Content-Type'],
-              'ETag'            => Digest::MD5.hexdigest(data[:body]),
-              'Key'             => object_name,
-              'Last-Modified'   => Fog::Time.now.to_date_header,
-              'Content-Length'  => options['Content-Length'] || data[:headers]['Content-Length'],
-              'StorageClass'    => options['x-amz-storage-class'] || 'STANDARD',
-              'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null'
-            }
+        require 'fog/aws/requests/storage/shared_mock_methods'
+        include Fog::Storage::AWS::SharedMockMethods
 
-            for key, value in options
-              case key
-              when 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-MD5', 'Expires', /^x-amz-meta-/
-                object[key] = value
-              end
-            end
+        def put_object(bucket_name, object_name, data, options = {})
+          define_mock_acl(bucket_name, object_name, options)
 
-            if bucket[:versioning]
-              bucket[:objects][object_name] ||= []
+          data = parse_mock_data(data)
+          bucket = verify_mock_bucket_exists(bucket_name)
 
-              # When versioning is suspended, putting an object will create a new 'null' version if the latest version
-              # is a value other than 'null', otherwise it will replace the latest version.
-              if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
-                bucket[:objects][object_name].shift
-              end
+          options['Content-Type'] ||= data[:headers]['Content-Type']
+          options['Content-Length'] ||= data[:headers]['Content-Length']
+          object = store_mock_object(bucket, object_name, data[:body], options)
 
-              bucket[:objects][object_name].unshift(object)
-            else
-              bucket[:objects][object_name] = [object]
-            end
+          response = Excon::Response.new
+          response.status = 200
 
-            response.headers = {
-              'Content-Length'   => object['Content-Length'],
-              'Content-Type'     => object['Content-Type'],
-              'ETag'             => object['ETag'],
-              'Last-Modified'    => object['Last-Modified'],
-            }
+          response.headers = {
+            'Content-Length'   => object['Content-Length'],
+            'Content-Type'     => object['Content-Type'],
+            'ETag'             => object['ETag'],
+            'Last-Modified'    => object['Last-Modified'],
+          }
 
-            response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({:expects => 200}, response))
-          end
+          response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
           response
         end
 

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

@@ -0,0 +1,87 @@
+module Fog
+  module Storage
+    class AWS
+      module SharedMockMethods
+        def define_mock_acl(bucket_name, object_name, options)
+          acl = options['x-amz-acl'] || 'private'
+          if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
+            raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
+          else
+            self.data[:acls][:object][bucket_name] ||= {}
+            self.data[:acls][:object][bucket_name][object_name] = self.class.acls(acl)
+          end
+        end
+
+        def parse_mock_data(data)
+          data = Fog::Storage.parse_data(data)
+          unless data[:body].is_a?(String)
+            data[:body] = data[:body].read
+          end
+          data
+        end
+
+        def verify_mock_bucket_exists(bucket_name)
+          if (bucket = self.data[:buckets][bucket_name])
+            return bucket
+          end
+
+          response = Excon::Response.new
+          response.status = 404
+          raise(Excon::Errors.status_error({:expects => 200}, response))
+        end
+
+        def get_upload_info(bucket_name, upload_id, delete = false)
+          if delete
+            upload_info = self.data[:multipart_uploads][bucket_name].delete(upload_id)
+          else
+            upload_info = self.data[:multipart_uploads][bucket_name][upload_id]
+          end
+
+          if !upload_info
+            response = Excon::Response.new
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+
+          upload_info
+        end
+
+        def store_mock_object(bucket, object_name, body, options)
+          object = {
+            :body             => body,
+            'Content-Type'    => options['Content-Type'],
+            'ETag'            => Digest::MD5.hexdigest(body),
+            'Key'             => object_name,
+            'Last-Modified'   => Fog::Time.now.to_date_header,
+            'Content-Length'  => options['Content-Length'],
+            'StorageClass'    => options['x-amz-storage-class'] || 'STANDARD',
+            'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null'
+          }
+
+          for key, value in options
+            case key
+            when 'Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-MD5', 'Expires', /^x-amz-meta-/
+              object[key] = value
+            end
+          end
+
+          if bucket[:versioning]
+            bucket[:objects][object_name] ||= []
+
+            # When versioning is suspended, putting an object will create a new 'null' version if the latest version
+            # is a value other than 'null', otherwise it will replace the latest version.
+            if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
+              bucket[:objects][object_name].shift
+            end
+
+            bucket[:objects][object_name].unshift(object)
+          else
+            bucket[:objects][object_name] = [object]
+          end
+
+          object
+        end
+      end
+    end
+  end
+end