fake_aws 0.0.2 → 0.0.3

data/spec/integration/s3/request_styles_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe "Request styles:" do
+  include S3IntegrationHelpers
+
+  let(:bucket)        { "mah-bucket" }
+  let(:file_name)     { "mah-file.txt"}
+  let(:file_contents) { "Hello, world!" }
+
+  before do
+    FileUtils.mkdir(File.join(s3_path, bucket))
+    File.write(File.join(s3_path, bucket, file_name), file_contents)
+  end
+
+  shared_examples "GET Object" do
+    it "returns a 200" do
+      response = get_example_file(file_name)
+      expect(response.status).to eq(200)
+    end
+
+    it "returns the contents of the file" do
+      response = get_example_file(file_name)
+      expect(response.body).to eq(file_contents)
+    end
+  end
+
+  context "path-style GET Object" do
+    def get_example_file(key)
+      connection.get("http://s3.amazonaws.com/#{bucket}/#{key}")
+    end
+
+    include_examples "GET Object"
+  end
+
+  context "virtual hosted-style GET Object" do
+    def get_example_file(key)
+      connection.get("http://#{bucket}.s3.amazonaws.com/#{key}")
+    end
+
+    include_examples "GET Object"
+  end
+
+  context "CNAME-style GET Object" do
+    let(:bucket) { "mah-bucket.mah-domain.com" }
+
+    def get_example_file(key)
+      connection.get("http://#{bucket}/#{key}")
+    end
+
+    include_examples "GET Object"
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -1,20 +1,5 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'fake_aws'
-require 'faraday'
 
-module S3IntegrationSpecHelpers
-  def self.included(base)
-    base.let(:s3_path) { "tmp" }
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
 
-    base.let(:connection) do
-      Faraday.new do |connection|
-        connection.adapter :rack, FakeAWS::S3::RackApp.new(s3_path)
-      end
-    end
-
-    base.before do
-      FileUtils.rm_r(s3_path) rescue Errno::ENOENT
-      FileUtils.mkdir(s3_path)
-    end
-  end
-end

data/spec/support/common_header_examples.rb

@@ -0,0 +1,16 @@
+# Headers that should exist in every S3 response.
+shared_examples "common response headers" do
+  it "has a Date header" do
+    time = Time.parse("2013-11-18 17:45")
+    allow(Time).to receive(:now).and_return(time)
+    expect(subject.headers["Date"]).to eq(time.httpdate)
+  end
+
+  it "has a Server header" do
+    expect(subject.headers["Server"]).to eq("AmazonS3")
+  end
+
+  it "has a request ID" do
+    expect(subject.headers["x-amz-request-id"]).to_not be_blank
+  end
+end

data/spec/support/s3_integration_helpers.rb

@@ -0,0 +1,18 @@
+require 'faraday'
+
+module S3IntegrationHelpers
+  def self.included(base)
+    base.let(:s3_path) { "tmp" }
+
+    base.let(:connection) do
+      Faraday.new("http://s3.amazonaws.com") do |connection|
+        connection.adapter :rack, FakeAWS::S3::RackApp.new(s3_path)
+      end
+    end
+
+    base.before do
+      FileUtils.rm_r(s3_path) rescue Errno::ENOENT
+      FileUtils.mkdir(s3_path)
+    end
+  end
+end

data/spec/support/xml_parsing_helper.rb

@@ -0,0 +1,7 @@
+require 'nori'
+
+module XMLParsingHelper
+  def parse_xml(xml)
+    Nori.new(:parser => :rexml).parse(xml)
+  end
+end

data/spec/unit/s3/bucket_on_disk_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::BucketOnDisk do
+  let(:root_directory)     { "tmp" }
+  let(:bucket)             { "mah-bucket" }
+
+  subject { described_class.new(root_directory, bucket) }
+
+  let(:bucket_path)        { "tmp/mah-bucket" }
+
+  before do
+    FileUtils.rm_r(root_directory) rescue Errno::ENOENT
+  end
+
+  describe "#exists?" do
+    it "returns true if the bucket directory exists" do
+      FileUtils.mkdir_p(bucket_path)
+      expect(subject.exists?).to be_truthy
+    end
+
+    it "returns false if the bucket directory doesn't exist" do
+      expect(subject.exists?).to be_falsy
+    end
+  end
+
+  describe "#create" do
+    it "creates the bucket directory" do
+      subject.create
+      expect(Dir.exists?(bucket_path)).to be_truthy
+    end
+  end
+
+  describe "#path" do
+    it "returns the path to the bucket" do
+      expect(subject.path).to eq(bucket_path)
+    end
+  end
+
+end

data/spec/unit/s3/error_index_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::ErrorIndex do
+
+  context ".error_for_code" do
+    it "returns something containing a description and status code for a known error" do
+      error = subject.error_for_code("NoSuchKey")
+      expect(error.description).to eq("The specified key does not exist.")
+      expect(error.status_code).to eq(404)
+    end
+
+    it "blows up if given an unknown error code" do
+      expect { subject.error_for_code("NotARealCode") }.to raise_error(FakeAWS::UnknownResponseErrorCode)
+    end
+  end
+
+end

data/spec/unit/s3/object_on_disk_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::ObjectOnDisk do
+  let(:key)            { "/mah-file.txt" }
+
+  let(:bucket_path)    { "tmp/mah-bucket" }
+  let(:object_path)    { "#{bucket_path}#{key}" }
+  let(:metadata_path)  { "#{object_path}.metadata.json" }
+
+  let(:bucket_on_disk) { double(:path => bucket_path) }
+
+  subject { described_class.new(bucket_on_disk, key) }
+
+  before do
+    FileUtils.rm_r(bucket_path) rescue Errno::ENOENT
+    FileUtils.mkdir_p(bucket_path)
+  end
+
+  describe "#exists?" do
+    it "returns true if the object file exists" do
+      File.write(object_path, "Hello, world!")
+      expect(subject.exists?).to be_truthy
+    end
+
+    it "returns false if the object file doesn't exist" do
+      expect(subject.exists?).to be_falsy
+    end
+  end
+
+  describe "#write" do
+    it "writes the content to the object file" do
+      subject.write("Hello, world!", { "bunnies" => "scary" })
+
+      expect(File.read(object_path)).to eq("Hello, world!")
+    end
+
+    it "writes the metadata to the metadata file as JSON" do
+      subject.write("Hello, world!", { "bunnies" => "scary" })
+
+      expect(File.read(metadata_path)).to eq('{"bunnies":"scary"}')
+    end
+  end
+
+  describe "#read_content" do
+    it "reads the contents of the object file" do
+      File.write(object_path, "Hello, world!")
+
+      expect(subject.read_content.read).to eq("Hello, world!")
+    end
+  end
+
+  describe "#read_metadata" do
+    it "returns an empty hash if there's no metadata file" do
+      expect(subject.read_metadata).to eq({})
+    end
+
+    it "returns the JSON from the metadata file converted to a hash" do
+      File.write(metadata_path, '{"bunnies":"scary"}')
+
+      expect(subject.read_metadata).to eq("bunnies" => "scary")
+    end
+  end
+
+  describe "#object_path" do
+    it "returns the path to the object" do
+      expect(subject.object_path).to eq(object_path)
+    end
+  end
+
+  describe "#metadata_path" do
+    it "returns the path to the metadata" do
+      expect(subject.metadata_path).to eq(metadata_path)
+    end
+  end
+
+  describe "#directory_path" do
+    it "returns the path to the directory containing the object" do
+      expect(subject.directory_path).to eq(bucket_path)
+    end
+  end
+
+end

data/spec/unit/s3/request_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::Request do
+  subject { described_class.new(env) }
+
+  context "#method" do
+    it "returns the request method" do
+      request = described_class.new("REQUEST_METHOD" => "GET")
+      expect(request.method).to eq("GET")
+    end
+  end
+
+  context "#content_type" do
+    it "returns the content type" do
+      request = described_class.new("CONTENT_TYPE" => "text/plain")
+      expect(request.content_type).to eq("text/plain")
+    end
+  end
+
+  context "#content" do
+    it "reads and returns the Rack input" do
+      rack_input = double("rack.input")
+      expect(rack_input).to receive(:read) { "foo" }
+      request = described_class.new("rack.input" => rack_input)
+      expect(request.content).to eq("foo")
+    end
+  end
+
+  context "#http_headers" do
+    it "returns the HTTP headers" do
+      request = described_class.new("HTTP_X_FOO" => "foo", "HTTP_X_BAR" => "bar")
+      expect(request.http_headers).to eq("x-foo" => "foo", "x-bar" => "bar")
+    end
+
+    it "ignores non-HTTP headers" do
+      request = described_class.new("FOO" => "foo")
+      expect(request.http_headers).to eq({})
+    end
+  end
+
+  shared_examples "request parsing" do
+    context "bucket request" do
+      let(:key) { "/" }
+
+      it "extracts the bucket" do
+        expect(request.bucket).to eq(bucket)
+      end
+
+      it "has no key" do
+        expect(request.has_key?).to be_falsy
+      end
+    end
+
+    context "object request" do
+      let(:key) { "/mah-object.txt" }
+
+      it "extracts the bucket" do
+        expect(request.bucket).to eq(bucket)
+      end
+
+      it "has a key" do
+        expect(request.has_key?).to be_truthy
+      end
+
+      it "extracts the key" do
+        expect(request.key).to eq(key)
+      end
+    end
+  end
+
+  context "path-style" do
+    let(:bucket) { "mah-bucket" }
+    subject(:request) { described_class.new("SERVER_NAME" => "s3.amazonaws.com", "PATH_INFO" => "/#{bucket}#{key}") }
+
+    include_examples "request parsing"
+  end
+
+  context "virtual hosted-style" do
+    let(:bucket) { "mah-bucket" }
+    subject(:request) { described_class.new("SERVER_NAME" => "#{bucket}.s3.amazonaws.com", "PATH_INFO" => key) }
+
+    include_examples "request parsing"
+  end
+
+  context "CNAME-style" do
+    let(:bucket) { "mah-bucket.mah-domain.com" }
+    subject(:request) { described_class.new("SERVER_NAME" => bucket, "PATH_INFO" => key) }
+
+    include_examples "request parsing"
+  end
+
+end

data/spec/unit/s3/responses/empty_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::Responses::Empty do
+  include_examples "common response headers"
+
+  it "has a status code of 200" do
+    expect(subject.status_code).to eq(200)
+  end
+
+  it "has an empty body" do
+    expect(subject.body).to be_empty
+  end
+
+end

data/spec/unit/s3/responses/error_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::Responses::Error do
+
+  # Stub out looking up the error information:
+  let(:error_code)  { "NoSuchKey" }
+  let(:error)       { double(:description => "The specified key does not exist.", :status_code => 404) }
+  let(:error_index) { double(:error_for_code => error) }
+  before            { stub_const("FakeAWS::S3::ErrorIndex", error_index) }
+
+  let(:resource) { "/mah-bucket/mah-object.txt" }
+
+  subject { described_class.new(error_code, "Resource" => resource) }
+
+  include_examples "common response headers"
+
+  it "has the right status code" do
+    expect(subject.status_code).to eq(error.status_code)
+  end
+
+  it "has a content type of XML" do
+    expect(subject.headers["Content-Type"]).to eq("application/xml")
+  end
+
+  context "body" do
+    include XMLParsingHelper
+
+    let(:parsed_body) { parse_xml(subject.body) }
+
+    it "contains the right code" do
+      expect(parsed_body["Error"]["Code"]).to eq(error_code)
+    end
+
+    it "contains the right message" do
+      expect(parsed_body["Error"]["Message"]).to eq(error.description)
+    end
+
+    it "contains any additional fields passed in" do
+      expect(parsed_body["Error"]["Resource"]).to eq(resource)
+    end
+
+    it "contains the right request ID" do
+      expect(parsed_body["Error"]["RequestId"]).to eq(subject.headers["x-amz-request-id"])
+    end
+  end
+
+end
+
+

data/spec/unit/s3/responses/success_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe FakeAWS::S3::Responses::Success do
+
+  let(:headers) { { "Content-Type" => "text/plain" } }
+  let(:body)    { "Hello, world!" }
+
+  subject { described_class.new(headers, body) }
+
+  include_examples "common response headers"
+
+  it "has a status code of 200" do
+    expect(subject.status_code).to eq(200)
+  end
+
+  it "has the right body" do
+    expect(subject.body).to eq(body)
+  end
+
+  it "has the right content type" do
+    expect(subject.headers["Content-Type"]).to eq("text/plain")
+  end
+
+end
+