riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/excon_backend_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'excon'
-rescue LoadError
-  warn "Skipping ExconBackend specs, excon library not found."
-else
-  $mock_server = DrbMockServer
-  $mock_server.maybe_start
-
-  describe Riak::Client::ExconBackend do
-    def setup_http_mock(method, uri, options={})
-      method  = method.to_s.upcase
-      uri     = URI.parse(uri)
-      path    = uri.path          || "/"
-      query   = uri.query         || ""
-      body    = options[:body]    || []
-      headers = options[:headers] || {}
-      headers['Content-Type']     ||= "text/plain"
-      status  = options[:status] ? Array(options[:status]).first.to_i : 200
-      @_mock_set = [status, headers, method, path, query, body]
-      $mock_server.expect(*@_mock_set)
-    end
-
-    before :each do
-      @client = Riak::Client.new(:http_port => $mock_server.port, :http_backend => :Excon) # Point to our mock
-      @node = @client.node
-      @backend = @client.new_http_backend if described_class.configured?
-      @_mock_set = false
-    end
-
-    after :each do
-      if @_mock_set
-        $mock_server.satisfied.should be_true #("Expected #{@_mock_set.inspect}, failed")
-      end
-    end
-
-    it_should_behave_like "HTTP backend"
-
-    it "should split long headers into 8KB chunks" do
-      # TODO: This doesn't actually inspect the emitted headers. How
-      # can it?
-      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "ok")
-      lambda do
-        @backend.put(200, @backend.path("/riak", "foo"), "body", {"Long-Header" => (["12345678"*10]*100).join(", ") })
-      end.should_not raise_error
-    end
-
-    it "should support IO objects as the request body on PUT" do
-      File.open(File.expand_path("../../fixtures/cat.jpg", __FILE__), 'rb') do |file|
-        lambda do
-          setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "ok")
-          @backend.put(200, @backend.path("/riak/","foo"), file)
-          $mock_server.satisfied.should be_true
-        end.should_not raise_error
-      end
-    end
-
-    it "should support IO objects as the request body on POST" do
-      File.open(File.expand_path("../../fixtures/cat.jpg", __FILE__), 'rb') do |file|
-        lambda do
-          setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "ok")
-          @backend.post(200, @backend.path("/riak/", "foo"), file)
-          $mock_server.satisfied.should be_true
-        end.should_not raise_error
-      end
-    end
-
-    context "checking the Excon Gem version" do
-      subject { described_class }
-
-      def suppress_warnings
-        original_verbosity = $VERBOSE
-        $VERBOSE = nil
-        result =  yield
-        $VERBOSE = original_verbosity
-        return result
-      end
-
-      def set_excon_version(v)
-        original_version = Excon::VERSION
-        suppress_warnings { Excon.const_set(:VERSION, v) }
-        yield
-        suppress_warnings {Excon.const_set(:VERSION, original_version)}
-      end
-
-      context "when it meets the minimum requirement" do
-        it { should be_configured }
-
-        context "and has a version number that is not *lexically* greater than the minimum version" do
-          around {|ex| set_excon_version("0.13.2", &ex) }
-          it { should be_configured }
-        end
-      end
-
-      context "when it does not meet the minimum requirement" do
-        around {|ex| set_excon_version("0.5.6", &ex) }
-        it { should_not be_configured }
-      end
-    end
-  end
-end

data/spec/riak/headers_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Util::Headers do
-  it "should include the Net::HTTPHeader module" do
-    Riak::Util::Headers.included_modules.should include(Net::HTTPHeader)
-  end
-
-  it "should be initially empty" do
-    Riak::Util::Headers.new.to_hash.should == {}
-  end
-
-  it "should parse a header line into the key and value" do
-    Riak::Util::Headers.parse("Content-Type: text/plain\r\n").should == ["Content-Type", "text/plain"]
-  end
-
-  it "should parse a header line and add it to the collection" do
-    h = Riak::Util::Headers.new
-    h.parse("Content-Type: text/plain\r\n")
-    h.to_hash.should == {"content-type" => ["text/plain"]}
-  end
-end

data/spec/riak/http_backend/configuration_spec.rb

@@ -1,273 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client::HTTPBackend::Configuration do
-  let(:client){ Riak::Client.new }
-  let(:node){ client.node }
-  subject { Riak::Client::HTTPBackend.new(client, node) }
-  let(:uri){ URI.parse("http://127.0.0.1:8098/") }
-
-  context "generating resource URIs" do
-    context "when using the old scheme" do
-      before { subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_raw", </ping>; rel="riak_kv_wm_ping", </stats>; rel="riak_kv_wm_stats", </mapred>; rel="riak_kv_wm_mapred"']}) }
-
-      it "should generate a ping path" do
-        url = subject.ping_path
-        url.should be_kind_of(URI)
-        url.path.should == '/ping'
-      end
-
-      it "should generate a stats path" do
-        url = subject.stats_path
-        url.should be_kind_of(URI)
-        url.path.should == '/stats'
-      end
-
-      it "should generate a mapred path" do
-        url = subject.mapred_path :chunked => true
-        url.should be_kind_of(URI)
-        url.path.should == '/mapred'
-        url.query.should == "chunked=true"
-      end
-
-      it "should generate a bucket list path" do
-        url = subject.bucket_list_path
-        url.should be_kind_of(URI)
-        url.path.should == '/riak'
-        url.query.should == 'buckets=true'
-      end
-
-      it "should generate a bucket properties path" do
-        url = subject.bucket_properties_path('test ')
-        url.should be_kind_of(URI)
-        url.path.should == '/riak/test%20'
-        url.query.should == "keys=false&props=true"
-      end
-
-      it "should generate a key list path" do
-        url = subject.key_list_path('test ')
-        url.should be_kind_of(URI)
-        url.path.should == '/riak/test%20'
-        url.query.should == 'keys=true&props=false'
-        url = subject.key_list_path('test ', :keys => :stream)
-        url.path.should == '/riak/test%20'
-        url.query.should == 'keys=stream&props=false'
-      end
-
-      it "should generate an object path" do
-        url = subject.object_path('test ', 'object/', :r => 3)
-        url.should be_kind_of(URI)
-        url.path.should == '/riak/test%20/object%2F'
-        url.query.should == 'r=3'
-      end
-
-      it "should generate a link-walking path" do
-        url = subject.link_walk_path('test ', 'object/', [Riak::WalkSpec.new(:bucket => 'foo')])
-        url.should be_kind_of(URI)
-        url.path.should == '/riak/test%20/object%2F/foo,_,_'
-      end
-
-      it "should raise an error when generating an index range path" do
-        expect { subject.index_range_path('test', 'index_bin', 'a', 'b') }.to raise_error
-      end
-
-      it "should raise an error when generating an index equal path" do
-        expect { subject.index_eq_path('test', 'index_bin', 'a') }.to raise_error
-      end
-    end
-
-    context "when using the new scheme" do
-      before { subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</buckets>; rel="riak_kv_wm_buckets", </ping>; rel="riak_kv_wm_ping", </stats>; rel="riak_kv_wm_stats", </mapred>; rel="riak_kv_wm_mapred"']}) }
-
-      it "should generate a ping path" do
-        url = subject.ping_path
-        url.should be_kind_of(URI)
-        url.path.should == '/ping'
-      end
-
-      it "should generate a stats path" do
-        url = subject.stats_path
-        url.should be_kind_of(URI)
-        url.path.should == '/stats'
-      end
-
-      it "should generate a mapred path" do
-        url = subject.mapred_path :chunked => true
-        url.should be_kind_of(URI)
-        url.path.should == '/mapred'
-        url.query.should == "chunked=true"
-      end
-
-      it "should generate a bucket list path" do
-        url = subject.bucket_list_path
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets'
-        url.query.should == 'buckets=true'
-      end
-
-      it "should generate a bucket properties path" do
-        url = subject.bucket_properties_path('test ')
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/props'
-        url.query.should be_nil
-      end
-
-      it "should generate a key list path" do
-        url = subject.key_list_path('test ')
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/keys'
-        url.query.should == 'keys=true'
-        url = subject.key_list_path('test ', :keys => :stream)
-        url.path.should == '/buckets/test%20/keys'
-        url.query.should == 'keys=stream'
-      end
-
-      it "should generate an object path" do
-        url = subject.object_path('test ', 'object/', :r => 3)
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/keys/object%2F'
-        url.query.should == 'r=3'
-      end
-
-      it "should generate a link-walking path" do
-        url = subject.link_walk_path('test ', 'object/', [Riak::WalkSpec.new(:bucket => 'foo')])
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/keys/object%2F/foo,_,_'
-      end
-
-      it "should generate an index range path" do
-        url = subject.index_range_path('test ', 'test_bin', 'a', 'b')
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/index/test_bin/a/b'
-      end
-
-      it "should generate an index equal path" do
-        url = subject.index_eq_path('test ', 'test_bin', 'a')
-        url.should be_kind_of(URI)
-        url.path.should == '/buckets/test%20/index/test_bin/a'
-      end
-    end
-  end
-
-  it "should memoize the server config" do
-    subject.should_receive(:get).with(200, uri).once.and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_link_walker",</mapred>; rel="riak_kv_wm_mapred",</ping>; rel="riak_kv_wm_ping",</riak>; rel="riak_kv_wm_raw",</stats>; rel="riak_kv_wm_stats"']})
-    subject.send(:riak_kv_wm_link_walker).should == "/riak"
-    subject.send(:riak_kv_wm_raw).should == "/riak"
-  end
-
-  context "generating Solr paths" do
-    context "when Riak Search is disabled" do
-      before {
-        subject.should_receive(:get).with(200, uri).once.and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_link_walker",</mapred>; rel="riak_kv_wm_mapred",</ping>; rel="riak_kv_wm_ping",</riak>; rel="riak_kv_wm_raw",</stats>; rel="riak_kv_wm_stats"']})
-      }
-
-      it "should raise an error" do
-        expect { subject.solr_select_path('foo', 'a:b') }.to raise_error
-        expect { subject.solr_update_path('foo') }.to raise_error
-      end
-    end
-
-    context "when Riak Search is enabled" do
-      before {
-        subject.should_receive(:get).with(200, uri).once.and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_link_walker",</mapred>; rel="riak_kv_wm_mapred",</ping>; rel="riak_kv_wm_ping",</riak>; rel="riak_kv_wm_raw",</stats>; rel="riak_kv_wm_stats", </solr>; rel="riak_solr_indexer_wm", </solr>; rel="riak_solr_searcher_wm"']})
-      }
-
-      it "should generate a search path for the default index" do
-        url = subject.solr_select_path(nil, 'a:b')
-        url.should be_kind_of(URI)
-        url.path.should == '/solr/select'
-        url.query.should include("q=a%3Ab")
-        url.query.should include('wt=json')
-      end
-
-      it "should generate a search path for a specified index" do
-        url = subject.solr_select_path('foo', 'a:b', 'wt' => 'xml')
-        url.should be_kind_of(URI)
-        url.path.should == '/solr/foo/select'
-        url.query.should include("q=a%3Ab")
-        url.query.should include('wt=xml')
-      end
-
-      it "should generate an indexing path for the default index" do
-        url = subject.solr_update_path(nil)
-        url.should be_kind_of(URI)
-        url.path.should == '/solr/update'
-      end
-
-      it "should generate an indexing path for a specified index" do
-        url = subject.solr_update_path('foo')
-        url.should be_kind_of(URI)
-        url.path.should == '/solr/foo/update'
-      end
-    end
-  end
-
-  context "when Luwak is enabled" do
-    before { subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_raw", </ping>; rel="riak_kv_wm_ping", </stats>; rel="riak_kv_wm_stats", </mapred>; rel="riak_kv_wm_mapred", </luwak>; rel="luwak_wm_file"']}) }
-
-    it "should generate a path for a file" do
-      url = subject.luwak_path('foo')
-      url.should be_kind_of(URI)
-      url.path.should == '/luwak/foo'
-    end
-
-    it "should generate a path for the root" do
-      url = subject.luwak_path(nil)
-      url.should be_kind_of(URI)
-      url.path.should == '/luwak'
-    end
-
-    it "should escape a nested path" do
-      url = subject.luwak_path("foo/bar/baz")
-      url.should be_kind_of(URI)
-      url.path.should == '/luwak/foo%2Fbar%2Fbaz'
-    end
-  end
-
-  context "when Luwak is disabled" do
-    before { subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_raw", </ping>; rel="riak_kv_wm_ping", </stats>; rel="riak_kv_wm_stats", </mapred>; rel="riak_kv_wm_mapred"']}) }
-
-    it "should raise an error when generating the path" do
-      expect { subject.luwak_path(nil) }.to raise_error
-      expect { subject.luwak_path('foo') }.to raise_error
-    end
-  end
-
-  {
-    :riak_kv_wm_raw => :prefix,
-    :riak_kv_wm_link_walker => :prefix,
-    :riak_kv_wm_mapred => :mapred
-  }.each do |resource, alternate|
-    it "should detect the #{resource} resource from the configuration URL" do
-      subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
-      subject.send(resource).should == "/path"
-    end
-
-    it "should fallback to node.http_paths[:#{alternate}] if the #{resource} resource is not found" do
-      subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</>; rel="top"']})
-      subject.send(resource).should == node.http_paths[alternate]
-    end
-
-    it "should fallback to node.http_paths[:#{alternate}] if request fails" do
-      subject.should_receive(:get).with(200, uri).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
-      subject.send(resource).should == node.http_paths[alternate]
-    end
-  end
-
-  {
-    :riak_kv_wm_ping => "/ping",
-    :riak_kv_wm_stats => "/stats"
-  }.each do |resource, default|
-    it "should detect the #{resource} resource from the configuration URL" do
-      subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
-      subject.send(resource).should == "/path"
-    end
-    it "should fallback to #{default.inspect} if the #{resource} resource is not found" do
-      subject.should_receive(:get).with(200, uri).and_return(:headers => {'link' => ['</>; rel="top"']})
-      subject.send(resource).should == default
-    end
-    it "should fallback to #{default.inspect} if request fails" do
-      subject.should_receive(:get).with(200, uri).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
-      subject.send(resource).should == default
-    end
-  end
-end

data/spec/riak/http_backend/object_methods_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client::HTTPBackend::ObjectMethods do
-  before :each do
-    @client = Riak::Client.new
-    @backend = Riak::Client::HTTPBackend.new(@client, @client.node)
-    @bucket = Riak::Bucket.new(@client, "bucket")
-    @object = Riak::RObject.new(@bucket, "bar")
-    @backend.stub!(:new_scheme?).and_return(false)
-  end
-
-  describe "loading object data from the response" do
-    it "should load the content type" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}})
-      @object.content_type.should == "application/json"
-    end
-
-    it "should load the body data" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => '{"foo":"bar"}'})
-      @object.raw_data.should be_present
-      @object.data.should be_present
-    end
-
-    it "should handle raw data properly" do
-      @object.should_not_receive(:deserialize) # optimize for the raw_data case, don't penalize people for using raw_data
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => body = '{"foo":"bar"}'})
-      @object.raw_data.should == body
-    end
-
-    it "should deserialize the body data" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => "{}"})
-      @object.data.should == {}
-    end
-
-    it "should leave the object data unchanged if the response body is blank" do
-      @object.data = "Original data"
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => "", :code => 304})
-      @object.data.should == "Original data"
-    end
-
-    it "should load the vclock from the headers" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], 'x-riak-vclock' => ["somereallylongbase64string=="]}, :body => "{}"})
-      @object.vclock.should == "somereallylongbase64string=="
-    end
-
-    it "should load links from the headers" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "link" => ['</riak/bar>; rel="up"']}, :body => "{}"})
-      @object.links.should have(1).item
-      @object.links.first.url.should == "/riak/bar"
-      @object.links.first.rel.should == "up"
-    end
-
-    it "should load the ETag from the headers" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "etag" => ["32748nvas83572934"]}, :body => "{}"})
-      @object.etag.should == "32748nvas83572934"
-    end
-
-    it "should load the modified date from the headers" do
-      time = Time.now
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "last-modified" => [time.httpdate]}, :body => "{}"})
-      @object.last_modified.to_s.should == time.to_s # bah, times are not equivalent unless equal
-    end
-
-    it "should load meta information from the headers" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "x-riak-meta-some-kind-of-robot" => ["for AWESOME"]}, :body => "{}"})
-      @object.meta["some-kind-of-robot"].should == ["for AWESOME"]
-    end
-
-    it "should load indexes from the headers" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "x-riak-index-email_bin" => ["sean@basho.com"], "x-riak-index-rank_int" => ["50"]}, :body => "{}"})
-      @object.indexes['email_bin'].should include('sean@basho.com')
-      @object.indexes['rank_int'].should include(50)
-    end
-
-    it "should parse the location header into the key when present" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/baz"]}})
-      @object.key.should == "baz"
-    end
-
-    it "should parse and escape the location header into the key when present" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/%5Bbaz%5D?vtag=1234"]}})
-      @object.key.should == "[baz]"
-    end
-
-    context "when the response code is 300 and the content-type is multipart/mixed" do
-      let(:http_response) { {:headers => {"content-type" => ["multipart/mixed; boundary=8XZD3w6ttFTHIz6LCmhVxn9Ex0K"]}, :code => 300, :body => File.read("spec/fixtures/multipart-basic-conflict.txt")} }
-      let(:other_object) { Riak::RObject.new(@bucket, "bar2") }
-
-      it 'marks the object as in conflict' do
-        @backend.load_object(@object, http_response)
-        @object.should be_conflict
-      end
-
-      it 'attempts to resolve the conflict' do
-        @object.should respond_to(:attempt_conflict_resolution)
-        @object.should_receive(:attempt_conflict_resolution).and_return(other_object)
-        @backend.load_object(@object, http_response).should be(other_object)
-      end
-    end
-
-    it "should unescape the key given in the location header" do
-      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/baz%20"]}})
-      @object.key.should == "baz "
-    end
-
-    describe "extracting siblings" do
-      before :each do
-        @backend.load_object(@object, {:headers => {"x-riak-vclock" => ["merged"], "content-type" => ["multipart/mixed; boundary=8XZD3w6ttFTHIz6LCmhVxn9Ex0K"]}, :code => 300, :body => File.read("spec/fixtures/multipart-basic-conflict.txt")})
-      end
-
-      it "should extract the siblings" do
-        @object.should have(2).siblings
-        siblings = @object.siblings
-        siblings[0].data.should == "bar"
-        siblings[1].data.should == "foo"
-      end
-    end
-  end
-
-  describe "headers used for storing the object" do
-    it "should include the content type" do
-      @object.content_type = "application/json"
-      @backend.store_headers(@object)["Content-Type"].should == "application/json"
-    end
-
-    it "should include the vclock when present" do
-      @object.vclock = "123445678990"
-      @backend.store_headers(@object)["X-Riak-Vclock"].should == "123445678990"
-    end
-
-    it "should exclude the vclock when nil" do
-      @object.vclock = nil
-      @backend.store_headers(@object).should_not have_key("X-Riak-Vclock")
-    end
-
-    describe "when conditional PUTs are requested" do
-      before :each do
-        @object.prevent_stale_writes = true
-      end
-
-      it "should include an If-None-Match: * header" do
-        @backend.store_headers(@object).should have_key("If-None-Match")
-        @backend.store_headers(@object)["If-None-Match"].should == "*"
-      end
-
-      it "should include an If-Match header with the etag when an etag is present" do
-        @object.etag = "foobar"
-        @backend.store_headers(@object).should have_key("If-Match")
-        @backend.store_headers(@object)["If-Match"].should == @object.etag
-      end
-    end
-
-    describe "when links are defined" do
-      before :each do
-        @object.links << Riak::Link.new("/riak/foo/baz", "next")
-      end
-
-      it "should include a Link header with references to other objects" do
-        @backend.store_headers(@object).should have_key("Link")
-        @backend.store_headers(@object)["Link"].should include('</riak/foo/baz>; riaktag="next"')
-      end
-
-      it "should exclude the 'up' link to the bucket from the header" do
-        @object.links << Riak::Link.new("/riak/foo", "up")
-        @backend.store_headers(@object).should have_key("Link")
-        @backend.store_headers(@object)["Link"].should_not include('riaktag="up"')
-      end
-
-      context "when using the new URL scheme" do
-        before { @backend.stub!(:new_scheme?).and_return(true) }
-
-        it "should encode Links using the new format" do
-          @backend.store_headers(@object).should have_key("Link")
-          @backend.store_headers(@object)['Link'].should include('</buckets/foo/keys/baz>; riaktag="next"')
-        end
-      end
-    end
-
-    it "should exclude the Link header when no links are present" do
-      @object.links = Set.new
-      @backend.store_headers(@object).should_not have_key("Link")
-    end
-
-    describe "when meta fields are present" do
-      before :each do
-        @object.meta = {"some-kind-of-robot" => true, "powers" => "for awesome", "cold-ones" => 10}
-      end
-
-      it "should include X-Riak-Meta-* headers for each meta key" do
-        @backend.store_headers(@object).should have_key("X-Riak-Meta-some-kind-of-robot")
-        @backend.store_headers(@object).should have_key("X-Riak-Meta-cold-ones")
-        @backend.store_headers(@object).should have_key("X-Riak-Meta-powers")
-      end
-
-      it "should turn non-string meta values into strings" do
-        @backend.store_headers(@object)["X-Riak-Meta-some-kind-of-robot"].should == "true"
-        @backend.store_headers(@object)["X-Riak-Meta-cold-ones"].should == "10"
-      end
-
-      it "should leave string meta values unchanged in the header" do
-        @backend.store_headers(@object)["X-Riak-Meta-powers"].should == "for awesome"
-      end
-    end
-
-    describe "when indexes are present" do
-      before :each do
-        @object.indexes = {"email_bin" => Set.new(['sean@basho.com', 'seancribbs@gmail.com']), "rank_int" => Set.new([50])}
-      end
-
-      it "should include X-Riak-Index-* headers for each index key" do
-        @backend.store_headers(@object).should have_key('X-Riak-Index-email_bin')
-        @backend.store_headers(@object).should have_key('X-Riak-Index-rank_int')
-      end
-
-      it "should join multi-valued indexes into a single header" do
-        @backend.store_headers(@object)['X-Riak-Index-email_bin'].should == 'sean@basho.com, seancribbs@gmail.com'
-      end
-
-      it "should turn integer indexes into strings in the header" do
-        @backend.store_headers(@object)['X-Riak-Index-rank_int'].should == '50'
-      end
-    end
-  end
-
-  describe "headers used for reloading the object" do
-    it "should be blank when the etag and last_modified properties are blank" do
-      @object.etag.should be_blank
-      @object.last_modified.should be_blank
-      @backend.reload_headers(@object).should be_blank
-    end
-
-    it "should include the If-None-Match key when the etag is present" do
-      @object.etag = "etag!"
-      @backend.reload_headers(@object)['If-None-Match'].should == "etag!"
-    end
-
-    it "should include the If-Modified-Since header when the last_modified time is present" do
-      time = Time.now
-      @object.last_modified = time
-      @backend.reload_headers(@object)['If-Modified-Since'].should == time.httpdate
-    end
-  end
-end