riak-client 0.9.8 → 1.0.0.beta

data/spec/riak/search_spec.rb

@@ -1,23 +1,6 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "Search mixins" do
-  before :all do
-    require 'riak/search'
-  end
+require 'spec_helper'
 
+describe "Search features" do
   describe Riak::Client do
     before :each do
       @client = Riak::Client.new
@@ -26,72 +9,73 @@ describe "Search mixins" do
     end
 
     describe "searching" do
-      it "should exclude the index from the URL when not specified" do
-        @http.should_receive(:get).with(200, "/solr", "select", hash_including("q" => "foo"), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+      it "should search the default index" do
+        @http.should_receive(:search).with(nil, "foo", {}).and_return({})
         @client.search("foo")
       end
 
-      it "should include extra options in the query string" do
-        @http.should_receive(:get).with(200, "/solr", "select", hash_including('rows' => 30), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+      it "should search the default index with additional options" do
+        @http.should_receive(:search).with(nil, 'foo', 'rows' => 30).and_return({})
         @client.search("foo", 'rows' => 30)
       end
 
-      it "should include the index in the URL when specified" do
-        @http.should_receive(:get).with(200, "/solr", "search", "select", hash_including("q" => "foo"), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+      it "should search the specified index" do
+        @http.should_receive(:search).with('search', 'foo', {}).and_return({})
         @client.search("search", "foo")
       end
-
-      it "should vivify JSON responses" do
-        @http.should_receive(:get).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => '{"response":{"docs":["foo"]}}'})
-        @client.search("foo").should == {"response" => {"docs" => ["foo"]}}
-      end
-
-      it "should return non-JSON responses raw" do
-        @http.should_receive(:get).and_return({:code => 200, :headers => {"content-type"=>["text/plain"]}, :body => '{"response":{"docs":["foo"]}}'})
-        @client.search("foo").should == '{"response":{"docs":["foo"]}}'
-      end
     end
-    describe "indexing documents" do
-      it "should exclude the index from the URL when not specified" do
-        @http.should_receive(:post).with(200, "/solr", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
-        @client.index({:id => 1, :field => "value"})
-      end
 
-      it "should include the index in the URL when specified" do
-        @http.should_receive(:post).with(200, "/solr", "foo", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
-        @client.index("foo", {:id => 1, :field => "value"})
+    describe "indexing documents" do
+      it "should update the default index" do
+        doc = {'field' => "value", 'id' => 1}
+        if doc.to_a.first.first == 'field'
+          expect_update_body('<add><doc><field name="field">value</field><field name="id">1</field></doc></add>')
+        else # 1.8.7, I hate you.
+          expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc></add>')
+        end
+        @client.index(doc)
+      end
+
+      it "should update the specified index" do
+        doc = {'field' => "value", 'id' => 1}
+        if doc.to_a.first.first == 'field'
+          expect_update_body('<add><doc><field name="field">value</field><field name="id">1</field></doc></add>', 'foo')
+        else # 1.8.7, I hate you.
+          expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc></add>', 'foo')
+        end
+        @client.index("foo", doc)
       end
 
       it "should raise an error when documents do not contain an id" do
-        @http.stub!(:post).and_return(true)
+        @http.stub!(:update_search_index).and_return(true)
         lambda { @client.index({:field => "value"}) }.should raise_error(ArgumentError)
         lambda { @client.index({:id => 1, :field => "value"}) }.should_not raise_error(ArgumentError)
       end
 
-      it "should build a Solr <add> request" do
-        expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc></add>')
-        @client.index({'id' => 1, 'field' => "value"})
-      end
-
       it "should include multiple documents in the <add> request" do
-        expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc><doc><field name="id">2</field><field name="foo">bar</field></doc></add>')
-        @client.index({'id' => 1, 'field' => "value"}, {'id' => 2, 'foo' => "bar"})
+        docs = {'field' => "value", 'id' => 1}, {'foo' => "bar", 'id' => 2}
+        if docs.first.to_a.first.first == 'field'
+          expect_update_body('<add><doc><field name="field">value</field><field name="id">1</field></doc><doc><field name="foo">bar</field><field name="id">2</field></doc></add>')
+        else # 1.8.7, I hate you
+          expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc><doc><field name="id">2</field><field name="foo">bar</field></doc></add>')
+        end
+        @client.index(*docs)
       end
     end
 
     describe "removing documents" do
-      it "should exclude the index from the URL when not specified" do
-        @http.should_receive(:post).with(200, "/solr","update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+      it "should remove documents from the default index" do
+        expect_update_body('<delete><id>1</id></delete>')
         @client.remove({:id => 1})
       end
 
-      it "should include the index in the URL when specified" do
-        @http.should_receive(:post).with(200, "/solr", "foo", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+      it "should remove documents from the specified index" do
+        expect_update_body('<delete><id>1</id></delete>', 'foo')
         @client.remove("foo", {:id => 1})
       end
 
       it "should raise an error when document specifications don't include an id or query" do
-        @http.stub!(:post).and_return({:code => 200})
+        @http.stub!(:update_search_index).and_return({:code => 200})
         lambda { @client.remove({:foo => "bar"}) }.should raise_error(ArgumentError)
         lambda { @client.remove({:id => 1}) }.should_not raise_error
       end
@@ -110,8 +94,7 @@ describe "Search mixins" do
     end
 
     def expect_update_body(body, index=nil)
-      args = [200, "/solr", index, "update", body, {"Content-Type" => "text/xml"}].compact
-      @http.should_receive(:post).with(*args).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+      @http.should_receive(:update_search_index).with(index, body)
     end
   end
 
@@ -122,11 +105,11 @@ describe "Search mixins" do
     end
 
     def load_without_index_hook
-      @bucket.instance_variable_set(:@props, {"precommit" => []})
+      @bucket.instance_variable_set(:@props, {"precommit" => [], "search" => false})
     end
 
     def load_with_index_hook
-      @bucket.instance_variable_set(:@props, {"precommit" => [{"mod" => "riak_search_kv_hook", "fun" => "precommit"}]})
+      @bucket.instance_variable_set(:@props, {"precommit" => [{"mod" => "riak_search_kv_hook", "fun" => "precommit"}], "search" => true})
     end
 
     it "should detect whether the indexing hook is installed" do
@@ -140,7 +123,7 @@ describe "Search mixins" do
     describe "enabling indexing" do
       it "should add the index hook when not present" do
         load_without_index_hook
-        @bucket.should_receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK]})
+        @bucket.should_receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK], "search" => true})
         @bucket.enable_index!
       end
 
@@ -154,7 +137,7 @@ describe "Search mixins" do
     describe "disabling indexing" do
       it "should remove the index hook when present" do
         load_with_index_hook
-        @bucket.should_receive(:props=).with({"precommit" => []})
+        @bucket.should_receive(:props=).with({"precommit" => [], "search" => false})
         @bucket.disable_index!
       end
 

data/spec/riak/serializers_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Riak::Serializers do
+  shared_examples_for "a serializer" do |type, deserialized, serialized|
+    context "for #{type}" do
+      it "serializes #{deserialized} to #{serialized}" do
+        described_class.serialize(type, deserialized).should == serialized
+      end
+
+      it "deserializes #{serialized} to #{deserialized}" do
+        described_class.deserialize(type, serialized).should == deserialized
+      end
+
+      it "round trips properly" do
+        str = described_class.serialize(type, deserialized)
+        described_class.deserialize(type, str).should == deserialized
+      end
+    end
+  end
+
+  it_behaves_like "a serializer", "text/plain", "a string", "a string"
+  it_behaves_like "a serializer", "application/json", { "a" => 7 }, %q|{"a":7}|
+  it_behaves_like "a serializer", "application/x-ruby-marshal", { :a => 3 }, Marshal.dump({ :a => 3 })
+
+  described_class::YAML_MIME_TYPES.each do |mime_type|
+    it_behaves_like "a serializer", mime_type, { "a" => 7 }, YAML.dump({ "a" => 7 })
+  end
+
+  %w[ serialize deserialize ].each do |meth|
+    describe ".#{meth}" do
+      it 'raises a NotImplementedError when given an unrecognized content type' do
+        expect {
+          described_class.send(meth, "application/unrecognized", "string")
+        }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+
+  describe "plain text serializer" do
+    it 'calls #to_s to convert the object to a string' do
+      described_class.serialize("text/plain", :a_string).should == "a_string"
+    end
+  end
+
+  describe "JSON serializer" do
+    it "respects the max nesting option" do
+      # Sadly, this spec will not fail for me when using yajl-ruby
+      # on Ruby 1.9, even when passing the options to #to_json is
+      # not implemented.
+      Riak.json_options = {:max_nesting => 51}
+      h = {}
+      p = h
+      (1..50).each do |i|
+        p['a'] = {}
+        p = p['a']
+      end
+      s = h.to_json(Riak.json_options)
+      expect {
+        described_class.serialize('application/json', h)
+      }.should_not raise_error
+
+      expect {
+        described_class.deserialize('application/json', s)
+      }.should_not raise_error
+    end
+  end
+
+  describe "a custom serializer" do
+    let(:custom_serializer) do
+      Object.new.tap do |o|
+        def o.dump(string)
+          "The string is: #{string}"
+        end
+
+        def o.load(string)
+          string.sub!(/^The string is: /, '')
+        end
+      end
+    end
+
+    it 'can be registered' do
+      described_class['application/custom-type-1'] = custom_serializer
+      described_class['application/custom-type-1'].should be(custom_serializer)
+    end
+
+    it_behaves_like "a serializer", "application/custom-type-a", "foo", "The string is: foo" do
+      before(:each) do
+        described_class['application/custom-type-a'] = custom_serializer
+      end
+    end
+  end
+end
+

data/spec/riak/stamp_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'riak/stamp'
+
+describe Riak::Stamp do
+  subject { described_class.new(Riak::Client.new) }
+  it "should generate always increasing integer identifiers" do
+    1000.times do
+      one = subject.next
+      two = subject.next
+      [one, two].should be_all {|i| Integer === i }
+      two.should > one
+    end
+  end
+
+  it "should delay until the next millisecond when the sequence overflows" do
+    old = subject.instance_variable_get(:@timestamp) + 0
+    subject.instance_variable_set(:@sequence, described_class::SEQUENCE_MASK)
+    count = 0
+    # Simulate the time_gen method returning the same thing multiple times
+    subject.stub(:time_gen) do
+      count += 1
+      if count < 10
+        old
+      else
+        old + 1
+      end
+    end
+    ((subject.next >> described_class::TIMESTAMP_SHIFT) & described_class::TIMESTAMP_MASK).should == old + 1
+  end
+
+  it "should raise an exception when the system clock moves backwards" do
+    old = subject.instance_variable_get(:@timestamp)
+    subject.should_receive(:time_gen).and_return(old - 10)
+    expect {
+      subject.next
+    }.to raise_error(Riak::BackwardsClockError)
+  end
+
+  # The client/worker ID should be used for disambiguation, not for
+  # primary ordering.  This breaks from the Snowflake model where the
+  # worker ID is in more significant bits.
+  it "should use the client ID as the bottom component of the identifier" do
+    (subject.next & described_class::CLIENT_ID_MASK).should == subject.client.client_id & described_class::CLIENT_ID_MASK
+  end
+
+  context "using a non-integer client ID" do
+    subject { described_class.new(Riak::Client.new(:client_id => "ripple")) }
+    let(:hash) { "ripple".hash }
+
+    it "should use the hash of the client ID as the bottom component of the identifier" do
+      (subject.next & described_class::CLIENT_ID_MASK).should == subject.client.client_id.hash & described_class::CLIENT_ID_MASK
+    end
+  end
+end

data/spec/riak/stream_parser_spec.rb

@@ -1,17 +1,4 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../spec_helper", File.dirname(__FILE__))
+require 'spec_helper'
 
 describe Riak::Util::Multipart::StreamParser do
   let(:klass) { Riak::Util::Multipart::StreamParser }
@@ -45,7 +32,7 @@ describe Riak::Util::Multipart::StreamParser do
     parser = klass.new do |result|
       block.ping
       result[:headers]['content-type'].should include("application/json")
-      lambda { JSON.parse(result[:body]) }.should_not raise_error
+      lambda { Riak::JSON.parse(result[:body]) }.should_not raise_error
     end
     File.open("spec/fixtures/multipart-mapreduce.txt", "r") do |f|
       while chunk = f.read(16)
@@ -59,7 +46,7 @@ describe Riak::Util::Multipart::StreamParser do
     parser = klass.new do |result|
       block.ping
       result[:headers]['content-type'].should include("application/json")
-      lambda { JSON.parse(result[:body]) }.should_not raise_error
+      lambda { Riak::JSON.parse(result[:body]) }.should_not raise_error
     end
     parser.accept File.read("spec/fixtures/multipart-mapreduce.txt")
   end

data/spec/riak/walk_spec_spec.rb

@@ -1,17 +1,4 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../spec_helper", File.dirname(__FILE__))
+require 'spec_helper'
 
 describe Riak::WalkSpec do
   describe "initializing" do

data/spec/spec_helper.rb

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
@@ -19,25 +6,33 @@ require 'riak'
 require 'rspec'
 require 'fakeweb'
 
-begin
-  require 'yaml'
-  require 'riak/test_server'
-  config = YAML.load_file("spec/support/test_server.yml")
-  $test_server = Riak::TestServer.new(config.symbolize_keys)
-  $test_server.prepare!
-  $test_server.start
-  at_exit { $test_server.cleanup }
-rescue => e
-  warn "Can't run Riak::TestServer specs. Specify the location of your Riak installation in spec/support/test_server.yml. See Riak::TestServer docs for more info."
-  warn e.inspect
-end
+# Only the tests should really get away with this.
+Riak.disable_list_keys_warnings = true
 
-Dir[File.join(File.dirname(__FILE__), "support", "*.rb")].sort.each {|f| require f }
+%w[integration_setup
+   http_backend_implementation_examples
+   unified_backend_examples
+   mocks
+   mock_server
+   drb_mock_server
+   test_server].each do |file|
+  require File.join("support", file)
+end
 
 RSpec.configure do |config|
+  config.debug = true
   config.mock_with :rspec
-  
+
+  config.before(:all, :integration => true) do
+    FakeWeb.allow_net_connect = true
+  end
+
+  config.after(:all, :integration => true) do
+    FakeWeb.allow_net_connect = false
+  end
+
   config.before(:each) do
+    Riak::RObject.on_conflict_hooks.clear
     FakeWeb.clean_registry
   end
 

data/spec/support/http_backend_implementation_examples.rb

@@ -1,65 +1,50 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 shared_examples_for "HTTP backend" do
+  let(:resource){ @backend.path("/riak/","foo") }
+
   describe "HEAD requests" do
     before :each do
-      setup_http_mock(:head, @backend.path("/riak/","foo").to_s, :body => "")
+      setup_http_mock(:head, resource.to_s, :body => "")
     end
 
     it "should return only the headers when the request succeeds" do
-      response = @backend.head(200, "/riak/","foo")
+      response = @backend.head(200, resource)
       response.should_not have_key(:body)
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.head(301, "/riak/", "foo") }.should raise_error(Riak::FailedRequest)
-    end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.head(200, "/riak/") }.should raise_error(ArgumentError)
+      lambda { @backend.head(301, resource) }.should raise_error(Riak::FailedRequest)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.head([200, 301], "/riak/", "foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.head([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
     end
   end
 
   describe "GET requests" do
     before :each do
-      setup_http_mock(:get, @backend.path("/riak/","foo").to_s, :body => "Success!")
+      setup_http_mock(:get, resource.to_s, :body => "Success!")
     end
 
     it "should return the response body and headers when the request succeeds" do
-      response = @backend.get(200, "/riak/","foo")
+      response = @backend.get(200, resource)
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.get(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.get(304, resource) }.should raise_error(Riak::FailedRequest)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.get([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.get([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
     end
-    
+
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.get(200, "/riak/","foo") do |chunk|
+      response = @backend.get(200, resource) do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -67,34 +52,30 @@ shared_examples_for "HTTP backend" do
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.get(200, "/riak/") }.should raise_error(ArgumentError)
-    end
   end
 
   describe "DELETE requests" do
     before :each do
-      setup_http_mock(:delete, @backend.path("/riak/","foo").to_s, :body => "Success!")
+      setup_http_mock(:delete, resource.to_s, :body => "Success!")
     end
 
     it "should return the response body and headers when the request succeeds" do
-      response = @backend.delete(200, "/riak/","foo")
+      response = @backend.delete(200, resource)
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.delete(304, "/riak/","foo") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.delete(304, resource) }.should raise_error(Riak::FailedRequest)
     end
-    
+
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.delete([200, 301], "/riak/","foo") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.delete([200, 301], resource) }.should_not raise_error(Riak::FailedRequest)
     end
-    
+
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.delete(200, "/riak/","foo") do |chunk|
+      response = @backend.delete(200, resource) do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -102,36 +83,32 @@ shared_examples_for "HTTP backend" do
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
-
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.delete(200, "/riak/") }.should raise_error(ArgumentError)
-    end
   end
 
   describe "PUT requests" do
     before :each do
-      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "Success!")
+      setup_http_mock(:put, resource.to_s, :body => "Success!")
     end
 
     it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.put(200, "/riak/","foo", "This is the body.")
+      response = @backend.put(200, resource, "This is the body.")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.put(204, "/riak/","foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.put(204, resource, "This is the body.") }.should raise_error(Riak::FailedRequest)
     end
-    
+
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.put([200, 204], "/riak/","foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.put([200, 204], resource, "This is the body.") }.should_not raise_error(Riak::FailedRequest)
     end
-    
-    
+
+
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.put(200, "/riak/","foo", "This is the body.") do |chunk|
+      response = @backend.put(200, resource, "This is the body.") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -140,42 +117,39 @@ shared_examples_for "HTTP backend" do
       response[:code].should == 200
     end
 
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.put(200, "/riak/") }.should raise_error(ArgumentError)
-    end
 
     it "should raise an error if no body data is given" do
-      lambda { @backend.put(200, "/riak/","foo") }.should raise_error(ArgumentError)
+      lambda { @backend.put(200, resource) }.should raise_error(ArgumentError)
     end
 
-    it "should raise an error if the body is not a string" do
-      lambda { @backend.put(200, "/riak/","foo", 123) }.should raise_error(ArgumentError)
+    it "should raise an error if the body is not a string or IO" do
+      lambda { @backend.put(200, resource, 123) }.should raise_error(ArgumentError)
     end
   end
 
   describe "POST requests" do
     before :each do
-      setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "Success!")
+      setup_http_mock(:post, resource.to_s, :body => "Success!")
     end
 
     it "should return the response body, headers, and code when the request succeeds" do
-      response = @backend.post(200, "/riak/","foo", "This is the body.")
+      response = @backend.post(200, resource, "This is the body.")
       response[:body].should == "Success!"
       response[:headers].should be_kind_of(Hash)
       response[:code].should == 200
     end
 
     it "should raise a FailedRequest exception when the request fails" do
-      lambda { @backend.post(204, "/riak/", "foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+      lambda { @backend.post(204, resource, "This is the body.") }.should raise_error(Riak::FailedRequest)
     end
 
     it "should not raise a FailedRequest if one of the expected response codes matches" do
-      lambda { @backend.post([200, 204], "/riak/", "foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+      lambda { @backend.post([200, 204], resource, "This is the body.") }.should_not raise_error(Riak::FailedRequest)
     end
 
     it "should yield successive chunks of the response to the given block but not return the entire body" do
       chunks = ""
-      response = @backend.post(200, "/riak/", "foo", "This is the body.") do |chunk|
+      response = @backend.post(200, resource, "This is the body.") do |chunk|
         chunks << chunk
       end
       chunks.should == "Success!"
@@ -184,16 +158,12 @@ shared_examples_for "HTTP backend" do
       response[:code].should == 200
     end
 
-    it "should raise an error if an invalid resource path is given" do
-      lambda { @backend.post(200, "/riak/") }.should raise_error(ArgumentError)
-    end
-
     it "should raise an error if no body data is given" do
-      lambda { @backend.post(200, "/riak/", "foo") }.should raise_error(ArgumentError)
+      lambda { @backend.post(200, resource) }.should raise_error(ArgumentError)
     end
 
-    it "should raise an error if the body is not a string" do
-      lambda { @backend.post(200, "/riak/", "foo", 123) }.should raise_error(ArgumentError)
+    it "should raise an error if the body is not a string or IO" do
+      lambda { @backend.post(200, resource, 123) }.should raise_error(ArgumentError)
     end
   end
 
@@ -201,11 +171,11 @@ shared_examples_for "HTTP backend" do
     [204, 205, 304].each do |code|
       [:get, :post, :put, :delete].each do |method|
         it "should not return a body on #{method.to_s.upcase} for #{code}" do
-          setup_http_mock(method, @backend.path("/riak/","foo").to_s, :status => code)
+          setup_http_mock(method, resource.to_s, :status => code)
           response = if method == :post || method == :put
-                       @backend.send(method, code,"/riak/","foo", "This is the body")
+                       @backend.send(method, code, resource, "This is the body")
                      else
-                       @backend.send(method, code, "/riak/", "foo")
+                       @backend.send(method, code, resource)
                      end
           response.should_not have_key(:body)
         end
@@ -218,7 +188,7 @@ shared_examples_for "HTTP backend" do
       @client.http_port = $mock_server.port + 1 unless @client.http_backend == :NetHTTP
       @client.ssl = true
       setup_http_mock(:get, @backend.path("/riak/","ssl").to_s, :body => "Success!")
-      response = @backend.get(200, "/riak/","ssl")
+      response = @backend.get(200,  @backend.path("/riak/","ssl"))
       response[:code].should == 200
     end
   end
@@ -229,13 +199,13 @@ shared_examples_for "HTTP backend" do
       if @client.http_backend == :NetHTTP
         setup_http_mock(:get, "http://ripple:rocks@127.0.0.1:8098/riak/auth", :body => 'Success!')
       else
-        @_mock_set = "Basic #{Base64::encode64("ripple:rocks").strip}" 
+        @_mock_set = "Basic #{Base64::encode64("ripple:rocks").strip}"
         $mock_server.attach do |env|
           $mock_server.satisfied = env['HTTP_AUTHORIZATION'] == @_mock_set
           [200, {}, Array('Success!')]
         end
       end
-      response = @backend.get(200, "/riak/", "auth")
+      response = @backend.get(200, @backend.path("/riak/", "auth"))
       response[:code].should == 200
     end
   end
@@ -244,9 +214,9 @@ shared_examples_for "HTTP backend" do
 
     def bad_request(method)
       if method == :post || method == :put
-        @backend.send(method, 200, "/riak/","foo", "body")
+        @backend.send(method, 200, resource, "body")
       else
-        @backend.send(method, 200, "/riak/","foo")
+        @backend.send(method, 200, resource)
       end
     end
 
@@ -254,7 +224,7 @@ shared_examples_for "HTTP backend" do
       context method.to_s do
 
         before(:each) do
-          setup_http_mock(method, @backend.path("/riak/","foo").to_s, :body => "Failure!", :status => 400, 'Content-Type' => 'text/plain' )
+          setup_http_mock(method, resource.to_s, :body => "Failure!", :status => 400, 'Content-Type' => 'text/plain' )
         end
 
         it "raises an HTTPFailedRequest exeption" do
@@ -273,7 +243,7 @@ shared_examples_for "HTTP backend" do
 
       end
     end
-    
+
   end
-  
+
 end