blobby 1.0.0

data/spec/blobby/http_store_spec.rb

@@ -0,0 +1,206 @@
+require "ostruct"
+require "blobby/http_store"
+require "blobby/in_memory_store"
+require "blobby/store_behaviour"
+require "sinatra/base"
+require "sham_rack"
+
+describe Blobby::HttpStore do
+
+  let(:backing_store) do
+    Hash.new
+  end
+
+  class FakeStorageService < Sinatra::Base
+
+    set :show_exceptions, false
+
+    put %r{/(.+)} do
+      halt 413 if request.content_type == "application/x-www-form-urlencoded"
+      status 201 unless store.key?(key)
+      store[key] = OpenStruct.new(:content_type => request.content_type, :body => request.body.read)
+      nil
+    end
+
+    get %r{/(.+)} do
+      halt 404 unless store.key?(key)
+      halt 200 if request.head?
+      content_type "application/octet-stream"
+      store[key].body
+    end
+
+    delete %r{/(.+)} do
+      halt 404 unless store.key?(key)
+      store.delete(key)
+      nil
+    end
+
+    def store
+      settings.backing_store
+    end
+
+    def key
+      params[:captures].first.tap do |key|
+        if key =~ /FAIL/ # simulate failure
+          fail "hell"
+        end
+      end
+    end
+
+  end
+
+  let(:fake_storage_service) do
+    subclass = Class.new(FakeStorageService)
+    subclass.set :backing_store, backing_store
+    subclass
+  end
+
+  let(:http_storage_host) { "storeit.com" }
+
+  before do
+    ShamRack.mount(fake_storage_service, http_storage_host)
+  end
+
+  after do
+    ShamRack.unmount_all
+  end
+
+  subject do
+    described_class.new("http://#{http_storage_host}/object-prefix/")
+  end
+
+  before do
+    allow(subject).to receive(:retry_intervals).and_return([0.01, 0.02])
+  end
+
+  it_behaves_like Blobby::Store
+
+  describe "#write" do
+
+    let(:content) { "CONTENT" }
+
+    before do
+      subject["foobar"].write(content)
+    end
+
+    it "PUTs stuff in the remote store" do
+      expect(backing_store["object-prefix/foobar"].body).to eq(content)
+    end
+
+    it "presents it as binary data" do
+      expect(backing_store["object-prefix/foobar"].content_type).to eq("application/octet-stream")
+    end
+
+  end
+
+  context "when a server error occurs" do
+
+    let(:key) { "SERVER/FAIL" }
+
+    describe "#read" do
+
+      it "raises an exception" do
+        expect do
+          subject[key].read
+        end.to raise_error
+      end
+
+    end
+
+    describe "#write" do
+
+      it "raises an exception" do
+        expect do
+          subject[key].write("something")
+        end.to raise_error
+      end
+
+    end
+
+  end
+
+  [EOFError, Errno::ECONNRESET].each do |retryable_exception|
+
+    context "when a transient #{retryable_exception} occurs" do
+
+      before do
+        allow(Net::HTTP).to receive(:start) do
+          allow(Net::HTTP).to receive(:start).and_call_original
+          fail retryable_exception, "interruptus connecti"
+        end
+      end
+
+      it "retries and recovers" do
+        subject["foo"].write("bar")
+        expect(subject["foo"].read).to eq("bar")
+      end
+
+    end
+
+    context "when #{retryable_exception} exceptions keep happening" do
+
+      before do
+        allow(Net::HTTP).to receive(:start) do
+          fail retryable_exception, "interruptus connecti"
+        end
+      end
+
+      it "raises the final exception" do
+        expect do
+          subject["anything"].exists?
+        end.to raise_error(retryable_exception)
+      end
+
+    end
+
+  end
+
+  context "when the hostname can't be resolved" do
+
+    before do
+      allow(Net::HTTP).to receive(:start) do
+        fail SocketError, "getaddrinfo: nodename nor servname provided, or not known"
+      end
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when HTTP server cannot be contacted" do
+
+    before do
+      allow(Net::HTTP).to receive(:start) do
+        fail Errno::ECONNREFUSED, "Connection refused - connect(2)"
+      end
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when the base_url does not include a trailing slash" do
+
+    subject do
+      described_class.new("http://#{http_storage_host}/prefix")
+    end
+
+    it "appends a trailing slash" do
+      expect(subject.base_uri.to_s).to eq("http://#{http_storage_host}/prefix/")
+    end
+
+  end
+
+  context "when the base_url does include a trailing slash" do
+
+    subject do
+      described_class.new("http://#{http_storage_host}/prefix/")
+    end
+
+    it "does not append another" do
+      expect(subject.base_uri.to_s).to eq("http://#{http_storage_host}/prefix/")
+    end
+
+  end
+
+end

data/spec/blobby/in_memory_store_spec.rb

@@ -0,0 +1,12 @@
+require "blobby/in_memory_store"
+require "blobby/store_behaviour"
+
+describe Blobby::InMemoryStore do
+
+  subject do
+    described_class.new
+  end
+
+  it_behaves_like Blobby::Store
+
+end

data/spec/blobby/key_transforming_store_spec.rb

@@ -0,0 +1,102 @@
+require "blobby/filesystem_store"
+require "blobby/key_transforming_store"
+require "blobby/store_behaviour"
+require "tmpdir"
+
+describe Blobby::KeyTransformingStore do
+
+  let(:memory) { Hash.new }
+
+  subject do
+    described_class.new(Blobby::InMemoryStore.new(memory)) { |key| key }
+  end
+
+  it_behaves_like Blobby::Store
+
+  let(:content) { "CONTENT" }
+
+  context "with a noop key transforming strategy" do
+
+    describe "#write" do
+
+      let(:key) { "NAMESPACED/KEY" }
+      let(:transformed_key) { key }
+
+      before do
+        subject[key].write(content)
+      end
+
+      it "uses the transformed key" do
+        expect(subject[key]).to exist
+        expect(memory.key?(transformed_key)).to be_truthy
+      end
+
+      it "has the correct contents" do
+        expect(subject[key].read).to eq(content)
+        expect(memory[transformed_key]).to eq(content)
+      end
+    end
+
+  end
+
+  context "with a sharding key transformation strategy" do
+
+    subject do
+      described_class.new(Blobby::InMemoryStore.new(memory)) do |key|
+        [key[0, 2], key[2, 2], key[4, 2], key].join "/"
+      end
+    end
+
+    describe "#write" do
+
+      let(:key) { "aabbccdd.png" }
+      let(:transformed_key) { "aa/bb/cc/aabbccdd.png" }
+
+      before do
+        subject[key].write(content)
+      end
+
+      it "uses the transformed key" do
+        expect(subject[key]).to exist
+        expect(memory.key?(transformed_key)).to be_truthy
+      end
+
+      it "has the correct contents" do
+        expect(subject[key].read).to eq(content)
+        expect(memory[transformed_key]).to eq(content)
+      end
+    end
+
+  end
+
+  context "with a shard ignoring key transformation strategy" do
+
+    subject do
+      described_class.new(Blobby::InMemoryStore.new(memory)) do |key|
+        key.split("/").last
+      end
+    end
+
+    describe "#write" do
+
+      let(:key) { "/aa/bb/cc/aabbccdd.png" }
+      let(:transformed_key) { "aabbccdd.png" }
+
+      before do
+        subject[key].write(content)
+      end
+
+      it "uses the transformed key" do
+        expect(subject[key]).to exist
+        expect(memory.key?(transformed_key)).to be_truthy
+      end
+
+      it "has the correct contents" do
+        expect(subject[key].read).to eq(content)
+        expect(memory[transformed_key]).to eq(content)
+      end
+    end
+
+  end
+
+end

data/spec/blobby/logging_store_spec.rb

@@ -0,0 +1,45 @@
+require "logger"
+require "blobby/in_memory_store"
+require "blobby/logging_store"
+require "blobby/store_behaviour"
+require "stringio"
+
+describe Blobby::LoggingStore do
+
+  let(:backing_store) { Blobby::InMemoryStore.new }
+  let(:log_buffer) { StringIO.new }
+  let(:logger) { Logger.new(log_buffer) }
+  let(:log_output) { log_buffer.string }
+
+  subject do
+    described_class.new(backing_store, "THE STORE", logger)
+  end
+
+  it_behaves_like Blobby::Store
+
+  describe "#write" do
+
+    before do
+      subject["foo"].write("bar")
+    end
+
+    it "logs the write" do
+      expect(log_output).to include(%(wrote to "foo" in THE STORE))
+    end
+
+  end
+
+  describe "#delete" do
+
+    before do
+      subject["foo"].write("bar")
+      subject["foo"].delete
+    end
+
+    it "logs the delete" do
+      expect(log_output).to include(%(deleted "foo" from THE STORE))
+    end
+
+  end
+
+end

data/spec/blobby/store_behaviour.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+
+require "rspec"
+
+module Blobby
+  module Store
+  end
+end
+
+shared_examples_for Blobby::Store do
+
+  let(:key) { "KEY" }
+  let(:content) { "CONTENT" }
+
+  it "is available" do
+    expect(subject).to be_available
+  end
+
+  context "for a valid key" do
+
+    let(:stored_object) { subject[key] }
+
+    context "when nothing has been stored" do
+
+      describe "#exists?" do
+        it "is false" do
+          expect(stored_object).not_to exist
+        end
+      end
+
+      describe "#read" do
+        it "returns nil" do
+          expect(stored_object.read).to be_nil
+        end
+      end
+
+      describe "#delete" do
+        it "returns false" do
+          expect(stored_object.delete).to eq(false)
+        end
+      end
+
+    end
+
+    context "after content has been written" do
+
+      before do
+        stored_object.write(content)
+      end
+
+      describe "#exists?" do
+        it "is true" do
+          expect(stored_object).to exist
+        end
+      end
+
+      describe "#read" do
+
+        it "returns the content" do
+          expect(stored_object.read).to eq(content)
+        end
+
+        context "with a block" do
+
+          before do
+            @chunks = []
+            @rval = stored_object.read do |chunk|
+              @chunks << chunk
+            end
+          end
+
+          it "yields the content in chunks" do
+            expect(@chunks.join).to eq(content)
+          end
+
+          it "returns nil" do
+            expect(@rval).to be_nil
+          end
+
+        end
+
+      end
+
+      describe "#delete" do
+        it "returns true" do
+          expect(stored_object.delete).to eq(true)
+        end
+
+        it "removes the object" do
+          stored_object.delete
+          expect(stored_object).not_to exist
+        end
+      end
+
+    end
+
+    if "Strings".respond_to?(:encoding)
+
+      context "for UTF-8 content" do
+
+        let(:content) { "SN☃WMAN" }
+
+        before do
+          stored_object.write(content)
+        end
+
+        describe "#read" do
+
+          it "returns binary data" do
+            expect(stored_object.read.encoding.name).to eq("ASCII-8BIT")
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#write" do
+
+      it "returns nil" do
+        expect(stored_object.write(content)).to be_nil
+      end
+
+      context "with a stream" do
+
+        before do
+          stored_object.write(StringIO.new(content))
+        end
+
+        it "writes the content of the stream" do
+          expect(stored_object.read).to eq(content)
+        end
+
+      end
+
+    end
+
+  end
+
+  class << self
+
+    def it_allows_keys_containing(description, example_key)
+      it "allows keys containing #{description}" do
+        expect { subject[example_key] }.not_to raise_error
+      end
+    end
+
+    def it_disallows_keys_containing(description, example_key)
+      it "disallows keys containing #{description}" do
+        expect { subject[example_key] }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+
+  it_disallows_keys_containing "nil", nil
+  it_disallows_keys_containing "blank", ""
+
+  it_allows_keys_containing "slashes", "foo/bar/baz"
+  it_allows_keys_containing "selected metacharacters", "@$&*.,;()~"
+
+  it_disallows_keys_containing "spaces", "foo bar"
+  it_disallows_keys_containing "tabs", "foo\tbar"
+  it_disallows_keys_containing "newlines", "foo\nbar"
+
+  it_disallows_keys_containing "a question mark", "foo?"
+  it_disallows_keys_containing "a colon", "foo:blah"
+
+  it_disallows_keys_containing "a leading slash", "/foo"
+  it_disallows_keys_containing "a trailing slash", "foo/"
+  it_disallows_keys_containing "double slashes", "foo//bar"
+
+end