fake_aws 0.0.2 → 0.0.3

data/lib/fake_aws/s3/rack_app.rb

@@ -7,18 +7,31 @@ module FakeAWS
       end
 
       def call(env)
-        operation_class = case env["REQUEST_METHOD"]
+        request = Request.new(env)
+        operation_for(request).call.to_rack_response
+      end
+
+    private
+
+      def operation_for(request)
+        operation_class(request).new(@directory, request)
+      end
+
+      def operation_class(request)
+        case request.method
           when "PUT"
-            Operations::PutObject
+            if request.has_key?
+              Operations::PutObject
+            else
+              Operations::PutBucket
+            end
           when "GET"
             Operations::GetObject
           else
-            raise "Unhandled request method"  # TODO: Make a proper exception for this.
+            raise FakeAWS::UnsupportedRequestError # TODO: This needs a spec.
         end
-
-        operation = operation_class.new(@directory, env)
-        operation.call
       end
+
     end
 
   end

data/lib/fake_aws/s3/request.rb

@@ -0,0 +1,100 @@
+module FakeAWS
+  module S3
+
+    # Extract the bucket and key from the various different styles of S3 request.
+    #
+    # See http://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html
+    class Request
+      def initialize(env)
+        @env = env
+        @server_name = env["SERVER_NAME"]
+        @path_info   = env["PATH_INFO"]
+      end
+
+      def method
+        @env["REQUEST_METHOD"]
+      end
+
+      def content_type
+        @env["CONTENT_TYPE"]
+      end
+
+      def content
+        @env["rack.input"].read
+      end
+
+      def http_headers
+        http_headers = env_headers.map {|key, value| [header_key_for_env_key(key), value] }
+        Hash[http_headers]
+      end
+
+      def bucket
+        @bucket ||= case request_style
+          when :path
+            path_components.first
+          when :virtual_hosted
+            server_name_components[0..-4].join(".")
+          when :cname
+            @server_name
+          else
+            raise "Uh oh"
+        end
+      end
+
+      def key
+        @key ||= "/" + case request_style
+          when :path
+            path_components.drop(1).join("/")
+          when :virtual_hosted, :cname
+            path_components.join("/")
+          else
+            raise "Uh oh"
+        end
+      end
+
+      def has_key?
+        key != "/"
+      end
+
+    private
+
+      def server_name
+        @server_name ||= @env["SERVER_NAME"]
+      end
+
+      def path_info
+        @path_info ||= @env["PATH_INFO"]
+      end
+
+      def server_name_components
+        @server_name_components ||= server_name.split(".")
+      end
+
+      def path_components
+        @path_components ||= path_info.split("/").drop(1)
+      end
+
+      def request_style
+        @request_style ||= if server_name =~ %r{s3[-\w\d]*\.amazonaws\.com$}
+          if server_name_components.length > 3
+            :virtual_hosted
+          else
+            :path
+          end
+        else
+          :cname
+        end
+      end
+
+      def env_headers
+        @env.select {|key, _| key.start_with?("HTTP_") }
+      end
+
+      def header_key_for_env_key(env_key)
+        env_key.sub(/^HTTP_/, "").gsub("_", "-").downcase
+      end
+
+    end
+
+  end
+end

data/lib/fake_aws/s3/responses/common.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+module FakeAWS
+  module S3
+    module Responses
+
+      # Useful things for generating responses to S3 requests.
+      module Common
+
+        # Headers which should be included in all S3 responses.
+        def common_headers
+          {
+            "Date"             => Time.now.httpdate,
+            "Server"           => "AmazonS3",
+            "x-amz-request-id" => request_id
+          }
+        end
+
+        def to_rack_response
+          [
+            status_code,
+            headers,
+            body
+          ]
+        end
+
+      protected
+
+        def request_id
+          @request_id ||= SecureRandom.hex(8)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fake_aws/s3/responses/empty.rb

@@ -0,0 +1,25 @@
+module FakeAWS
+  module S3
+    module Responses
+
+      class Empty
+        include Common
+
+        def status_code
+          200
+        end
+
+        def headers
+          common_headers
+        end
+
+        def body
+          ""
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/fake_aws/s3/responses/error.rb

@@ -0,0 +1,50 @@
+module FakeAWS
+  module S3
+    module Responses
+
+      class Error
+        include Common
+
+        def initialize(error_code, fields = {})
+          @error_code = error_code
+          @fields     = fields
+        end
+
+        def status_code
+          error.status_code
+        end
+
+        def headers
+          @headers ||= common_headers.merge("Content-Type" => "application/xml")
+        end
+
+        def body
+          "".tap do |xml|
+            xml << %q{<?xml version="1.0" encoding="UTF-8"?>\n}
+            xml << %q{<Error>}
+
+            xml << "  <Code>#{@error_code}</Code>"
+            xml << "  <Message>#{error.description}</Message>"
+
+            @fields.each_pair do |key, value|
+              xml << "  <#{key}>#{value}</#{key}>"
+            end
+
+            xml << "  <RequestId>#{request_id}</RequestId>"
+
+            xml << %q{</Error>}
+          end
+        end
+
+      private
+
+        def error
+          @error ||= FakeAWS::S3::ErrorIndex.error_for_code(@error_code)
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/fake_aws/s3/responses/success.rb

@@ -0,0 +1,31 @@
+module FakeAWS
+  module S3
+    module Responses
+
+      class Success
+        include Common
+
+        def initialize(headers, body)
+          @headers = headers
+          @body    = body
+        end
+
+        def status_code
+          200
+        end
+
+        def headers
+          common_headers.merge(@headers)
+        end
+
+        def body
+          @body
+        end
+      end
+
+    end
+  end
+end
+
+
+

data/lib/fake_aws/version.rb

@@ -1,3 +1,3 @@
 module FakeAWS
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/integration/s3/get_object_spec.rb

@@ -1,12 +1,17 @@
 require 'spec_helper'
 
 describe "S3 GET Object operation" do
-  include S3IntegrationSpecHelpers
+  include S3IntegrationHelpers
+  include XMLParsingHelper
 
   let(:bucket)        { "mah-bucket" }
   let(:file_name)     { "mah-file.txt"}
   let(:file_contents) { "Hello, world!" }
 
+  def set_metadata(metadata)
+    File.write(File.join(s3_path, bucket, "#{file_name}.metadata.json"), metadata.to_json)
+  end
+
   def get_example_file(key)
     connection.get(File.join(bucket, key))
   end
@@ -17,27 +22,34 @@ describe "S3 GET Object operation" do
       File.write(File.join(s3_path, bucket, file_name), file_contents)
     end
 
-    it "returns a 200" do
+    it "returns a successful response" do
       response = get_example_file(file_name)
       expect(response.status).to eq(200)
     end
 
-    it "returns a correctly constructed response"
-
     it "returns the contents of the file" do
       response = get_example_file(file_name)
       expect(response.body).to eq(file_contents)
     end
 
     it "returns the right content type" do
-      file_metadata = {
-        "Content-Type" => "text/plain"
-      }.to_json
-      File.write(File.join(s3_path, bucket, "#{file_name}.metadata.json"), file_metadata)
+      set_metadata("Content-Type" => "text/plain")
 
       response = get_example_file(file_name)
       expect(response.headers["Content-Type"]).to eq("text/plain")
     end
+
+    it "returns a content type of application/octet-stream if none is set" do
+      response = get_example_file(file_name)
+      expect(response.headers["Content-Type"]).to eq("application/octet-stream")
+    end
+
+    it "returns x-amz-meta-* headers from the metadata" do
+      set_metadata("x-amz-meta-foo" => "bar")
+
+      response = get_example_file(file_name)
+      expect(response.headers["x-amz-meta-foo"]).to eq("bar")
+    end
   end
 
   context "with a file that doesn't exist" do
@@ -45,17 +57,28 @@ describe "S3 GET Object operation" do
       FileUtils.mkdir(File.join(s3_path, bucket))
     end
 
-    it "returns a 404" do
+    it "returns a NoSuchKey error" do
       response = get_example_file(file_name)
       expect(response.status).to eq(404)
+      expect(parse_xml(response.body)["Error"]["Code"]).to eq("NoSuchKey")
     end
 
-    it "returns the correct XML response"
+    it "returns the key as the resource" do
+      response = get_example_file(file_name)
+      expect(parse_xml(response.body)["Error"]["Resource"]).to eq("/#{file_name}")
+    end
   end
 
   context "with a bucket that doesn't exist" do
-    it "returns the right sort of error" do
-      pending "Need to figure out what error AWS actually returns for this case"
+    it "returns a NoSuchBucket error" do
+      response = get_example_file(file_name)
+      expect(response.status).to eq(404)
+      expect(parse_xml(response.body)["Error"]["Code"]).to eq("NoSuchBucket")
+    end
+
+    it "returns the bucket name" do
+      response = get_example_file(file_name)
+      expect(parse_xml(response.body)["Error"]["BucketName"]).to eq(bucket)
     end
   end
 

data/spec/integration/s3/put_bucket_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "S3 PUT Bucket operation" do
+  include S3IntegrationHelpers
+  include XMLParsingHelper
+
+  let(:bucket)      { "mah-bucket" }
+  let(:bucket_path) { File.join(s3_path, bucket) }
+
+  def put_bucket
+    connection.put do |request|
+      request.url("http://#{bucket}.s3.amazonaws.com")
+    end
+  end
+
+  context "without an existing bucket" do
+    it "returns a 200" do
+      response = put_bucket
+      expect(response.status).to eq(200)
+    end
+
+    it "creates the bucket directory on disk" do
+      response = put_bucket
+      expect(Dir.exist?(bucket_path)).to be_truthy
+    end
+  end
+
+  context "with an existing bucket" do
+    before do
+      Dir.mkdir(bucket_path)
+    end
+
+    it "returns a Bucket Already Exists error" do
+      response = put_bucket
+      expect(response.status).to eq(409)
+      expect(parse_xml(response.body)["Error"]["Code"]).to eq("BucketAlreadyExists")
+    end
+  end
+
+end

data/spec/integration/s3/put_object_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe "S3 PUT Object operation" do
-  include S3IntegrationSpecHelpers
+  include S3IntegrationHelpers
+  include XMLParsingHelper
 
   let(:bucket)        { "mah-bucket" }
   let(:file_name)     { "mah-file.txt"}
@@ -31,7 +32,10 @@ describe "S3 PUT Object operation" do
       expect(response.status).to eq(200)
     end
 
-    it "returns a correctly constructed response"
+    it "returns a response with an empty body" do
+      response = put_example_file(file_name)
+      expect(response.body).to be_empty
+    end
 
     it "creates a file" do
       put_example_file(file_name)
@@ -65,12 +69,16 @@ describe "S3 PUT Object operation" do
   end
 
   context "without an existing bucket" do
-    it "returns a 404" do
+    it "returns a No Such Bucket error" do
       response = put_example_file(file_name)
       expect(response.status).to eq(404)
+      expect(parse_xml(response.body)["Error"]["Code"]).to eq("NoSuchBucket")
     end
 
-    it "returns the correct XML response"
+    it "returns the bucket name" do
+      response = put_example_file(file_name)
+      expect(parse_xml(response.body)["Error"]["BucketName"]).to eq(bucket)
+    end
   end
 
 end