riak-client 0.8.3 → 0.9.0.beta

data/spec/riak/escape_spec.rb

@@ -33,4 +33,11 @@ describe Riak::Util::Escape do
   it "should convert the bucket or key to a string before escaping" do
     @object.escape(125).should == '125'
   end
+
+  it "should unescape escaped strings" do
+    @object.unescape("some%20string").should == "some string"
+    @object.unescape("another%5Eone").should == "another^one"
+    @object.unescape("bracket%5Bone").should == "bracket[one"
+    @object.unescape("some%2Finner%2Fpath").should == "some/inner/path"
+  end
 end

data/spec/riak/http_backend/object_methods_spec.rb

@@ -0,0 +1,218 @@
+# 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__))
+
+describe Riak::Client::HTTPBackend::ObjectMethods do
+  before :each do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+    @object = Riak::RObject.new(@bucket, "bar")
+  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
+      @object.should_receive(:deserialize).with("{}").and_return({})
+      @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 => ""})
+      @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 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"]}})
+      @object.key.should == "[baz]"
+    end
+
+    it "should be in conflict when the response code is 300 and the content-type is multipart/mixed" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["multipart/mixed; boundary=foo"]}, :code => 300 })
+      @object.should be_conflict
+    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=foo"]}, :code => 300, :body => "\n--foo\nContent-Type: text/plain\n\nbar\n--foo\nContent-Type: text/plain\n\nbaz\n--foo--\n"})
+      end
+
+      it "should extract the siblings" do
+        @object.should have(2).siblings
+        siblings = @object.siblings
+        siblings[0].data.should == "bar"
+        siblings[1].data.should == "baz"
+      end
+
+      it "should set the key on both siblings" do
+        @object.siblings.should be_all {|s| s.key == "bar" }
+      end
+
+      it "should set the vclock on both siblings to the merged vclock" do
+        @object.siblings.should be_all {|s| s.vclock == "merged" }
+      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
+    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
+  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

data/spec/riak/http_backend_spec.rb

@@ -17,6 +17,7 @@ describe Riak::Client::HTTPBackend do
   before :each do
     @client = Riak::Client.new
     @backend = Riak::Client::HTTPBackend.new(@client)
+    @backend.instance_variable_set(:@server_config, {})
   end
 
   it "should take the Riak::Client when creating" do
@@ -28,104 +29,242 @@ describe Riak::Client::HTTPBackend do
     @backend.client.should == @client
   end
 
-  it "should generate default headers for requests based on the client settings" do
-    @client.client_id = "testing"
-    @backend.default_headers.should == {"X-Riak-ClientId" => "testing", "Accept" => "multipart/mixed, application/json;q=0.7, */*;q=0.5"}
-  end
+  context "pinging the server" do
+    it "should succeed on 200" do
+      @backend.should_receive(:get).with(200, "/ping", {}, {}).and_return({:code => 200, :body => "OK"})
+      @backend.ping.should be_true
+    end
 
-  it "should generate a root URI based on the client settings" do
-    @backend.root_uri.should be_kind_of(URI)
-    @backend.root_uri.to_s.should == "http://127.0.0.1:8098"
+    it "should fail on any other code or error" do
+      @backend.should_receive(:get).and_raise("socket closed")
+      @backend.ping.should be_false
+    end
   end
 
-  it "should compute a URI from a relative resource path" do
-    @backend.path("baz").should be_kind_of(URI)
-    @backend.path("foo").to_s.should == "http://127.0.0.1:8098/foo"
-    @backend.path("foo", "bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
-    @backend.path("/foo/bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
+  context "fetching an object" do
+    it "should perform a GET request and return an RObject" do
+      @backend.should_receive(:get).with([200,300], "/riak/","foo", "db", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @backend.fetch_object("foo", "db").should be_kind_of(Riak::RObject)
+    end
+
+    it "should pass the R quorum as a query parameter" do
+      @backend.should_receive(:get).with([200,300], "/riak/","foo", "db", {:r => 2}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @backend.fetch_object("foo", "db", 2)
+    end
+
+    it "should escape the bucket and key names" do
+      @backend.should_receive(:get).with([200,300], "/riak/","foo%20", "%20bar", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @backend.fetch_object('foo ',' bar').should be_kind_of(Riak::RObject)
+    end
   end
 
-  it "should compute a URI from a relative resource path with a hash of query parameters" do
-    @backend.path("baz", :r => 2).to_s.should == "http://127.0.0.1:8098/baz?r=2"
+  context "reloading an object" do
+    before do
+      @object = Riak::RObject.new(@client.bucket("foo"), "bar")
+    end
+
+    it "should use conditional request headers" do
+      @object.etag = "etag"
+      @backend.should_receive(:get).with([200,300,304], "/riak/", "foo", "bar", {}, {'If-None-Match' => "etag"}).and_return({:code => 304})
+      @backend.reload_object(@object)
+    end
+
+    it "should return without modifying the object if the response is 304 Not Modified" do
+      @backend.should_receive(:get).and_return({:code => 304})
+      @backend.should_not_receive(:load_object)
+      @backend.reload_object(@object)
+    end
+
+    it "should raise an exception when the response code is not 200 or 304" do
+      @backend.should_receive(:get).and_raise(Riak::FailedRequest.new(:get, 200, 500, {}, ''))
+      lambda { @backend.reload_object(@object) }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should escape the bucket and key names" do
+      # @bucket.should_receive(:name).and_return("some/deep/path")
+      @object.bucket = @client.bucket("some/deep/path")
+      @object.key = "another/deep/path"
+      @backend.should_receive(:get).with([200,300,304], "/riak/", "some%2Fdeep%2Fpath", "another%2Fdeep%2Fpath", {}, {}).and_return({:code => 304})
+      @backend.reload_object(@object)
+    end
   end
 
-  it "should raise an error if a resource path is too short" do
-    lambda { @backend.verify_path!(["/riak/"]) }.should raise_error(ArgumentError)
-    lambda { @backend.verify_path!(["/riak/", "foo"]) }.should_not raise_error
-    lambda { @backend.verify_path!(["/mapred"]) }.should_not raise_error
+  context "storing an object" do
+    before do
+      @bucket = Riak::Bucket.new(@client, "foo")
+      @object = Riak::RObject.new(@bucket)
+      @object.content_type = "text/plain"
+      @object.data = "This is some text."
+      @headers = @backend.store_headers(@object)
+    end
+
+    it "should use the raw_data as the request body" do
+      @object.content_type = "application/json"
+      body = @object.raw_data = "{this is probably invalid json!}}"
+      @backend.stub(:post).and_return({})
+      @object.should_not_receive(:serialize)
+      @backend.store_object(@object, false)
+    end
+    
+    context "when the object has no key" do
+      it "should issue a POST request to the bucket, and update the object properties (returning the body by default)" do
+        @backend.should_receive(:post).with(201, "/riak/", "foo", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
+        @backend.store_object(@object, true, nil, nil)
+        @object.key.should == "somereallylongstring"
+        @object.vclock.should == "areallylonghashvalue"
+      end
+
+      it "should include persistence-tuning parameters in the query string" do
+        @backend.should_receive(:post).with(201, "/riak/", "foo", {:dw => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
+        @backend.store_object(@object, true, nil, 2)
+      end
+
+      it "should escape the bucket name" do
+        @object.bucket = @client.bucket("foo ")
+        @backend.should_receive(:post).with(201, "/riak/", "foo%20", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
+        @backend.store_object(@object, true)
+      end
+    end
+
+    context "when the object has a key" do
+      before :each do
+        @object.key = "bar"
+      end
+
+      it "should issue a PUT request to the bucket, and update the object properties (returning the body by default)" do
+        @backend.should_receive(:put).with([200,204,300], "/riak/", "foo/bar", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
+        @backend.store_object(@object, true, nil, nil)
+        @object.key.should == "somereallylongstring"
+        @object.vclock.should == "areallylonghashvalue"
+      end
+      
+      it "should include persistence-tuning parameters in the query string" do
+        @backend.should_receive(:put).with([200,204,300], "/riak/", "foo/bar", {:w => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
+        @backend.store_object(@object, true, 2, nil)
+      end
+
+      it "should escape the bucket and key names" do
+        @backend.should_receive(:put).with([200,204,300], "/riak/", "foo%20/bar%2Fbaz", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
+        @bucket.instance_variable_set(:@name, "foo ")
+        @object.key = "bar/baz"
+        @backend.store_object(@object, true, nil, nil)
+      end
+    end
   end
 
-  describe "verify_path_and_body!" do
-    it "should separate the path and body from given arguments" do
-      uri, data = @backend.verify_path_and_body!(["/riak/", "foo", "This is the body."])
-      uri.should == ["/riak/", "foo"]
-      data.should == "This is the body."
+  context "deleting an object" do
+    it "should perform a DELETE request" do
+      @backend.should_receive(:delete).with([204,404], "/riak/", "foo", 'bar',{},{}).and_return(:code => 204)
+      @backend.delete_object("foo", "bar")
     end
 
-    it "should raise an error if the body is not a string or IO" do
-      lambda { @backend.verify_path_and_body!(["/riak/", "foo", nil]) }.should raise_error(ArgumentError)
-      lambda { @backend.verify_path_and_body!(["/riak/", "foo", File.open("spec/fixtures/cat.jpg")]) }.should_not raise_error(ArgumentError)
+    it "should escape the bucket and key names" do
+      @backend.should_receive(:delete).with([204,404], "/riak/", "bucket%20spaces", "deep%2Fpath",{},{}).and_return({:code => 204, :headers => {}})
+      @backend.delete_object("bucket spaces", "deep/path")
     end
+  end
 
-    it "should raise an error if a body is not given" do
-      lambda { @backend.verify_path_and_body!(["/riak/", "foo"])}.should raise_error(ArgumentError)
+  context "fetching bucket properties" do
+    it "should GET the bucket URL and parse the response as JSON" do
+      @backend.should_receive(:get).with(200, "/riak/", "foo", {:keys => false, :props => true}, {}).and_return({:body => '{"props":{"n_val":3}}'})
+      @backend.get_bucket_props("foo").should == {"n_val" => 3}
     end
 
-    it "should raise an error if a path is not given" do
-      lambda { @backend.verify_path_and_body!(["/riak/"])}.should raise_error(ArgumentError)
+    it "should escape the bucket name" do
+      @backend.should_receive(:get).with(200, "/riak/", "foo%20bar", {:keys => false, :props => true}, {}).and_return({:body => '{"props":{"n_val":3}}'})
+      @backend.get_bucket_props("foo bar")
+    end
+  end
+  
+  context "setting bucket properties" do
+    it "should PUT the properties to the bucket URL as JSON" do
+      @backend.should_receive(:put).with(204, "/riak/","foo", '{"props":{"n_val":2}}', {"Content-Type" => "application/json"}).and_return({:body => "", :headers => {}})
+      @backend.set_bucket_props("foo", {:n_val => 2})      
+    end
+    
+    it "should escape the bucket name" do
+      @backend.should_receive(:put).with(204, "/riak/","foo%20bar", '{"props":{"n_val":2}}', {"Content-Type" => "application/json"}).and_return({:body => "", :headers => {}})
+      @backend.set_bucket_props("foo bar", {:n_val => 2})
     end
   end
   
-  describe "detecting valid response codes" do
-    it "should accept strings or integers for either argument" do
-      @backend.should be_valid_response("300", "300")
-      @backend.should be_valid_response(300, "300")
-      @backend.should be_valid_response("300", 300)
+  context "listing keys" do
+    it "should unescape key names" do
+      @backend.should_receive(:get).with(200, "/riak/","foo", {:props => false, :keys => true}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar%20baz"]}'})
+      @backend.list_keys("foo").should == ["bar baz"]
     end
 
-    it "should accept an array of strings or integers for the expected code" do
-      @backend.should be_valid_response([200,304], "200")
-      @backend.should be_valid_response(["200",304], "200")
-      @backend.should be_valid_response([200,"304"], "200")
-      @backend.should be_valid_response(["200","304"], "200")
-      @backend.should be_valid_response([200,304], 200)
+    it "should escape the bucket name" do
+      @backend.should_receive(:get).with(200, "/riak/","unescaped%20", {:props => false, :keys => true}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar"]}'})
+      @backend.list_keys("unescaped ").should == ["bar"]
     end
+  end
 
-    it "should be false when none of the response codes match" do
-      @backend.should_not be_valid_response(200, 404)
-      @backend.should_not be_valid_response(["200","304"], 404)
-      @backend.should_not be_valid_response([200,304], 404)
+  context "listing buckets" do
+    it "should GET the raw URL with ?buckets=true and parse the response as JSON" do
+      @backend.should_receive(:get).with(200, "/riak/", {:buckets => true}, {}).and_return({:body => '{"buckets":["foo", "bar", "baz"]}'})
+      @backend.list_buckets.should == ["foo", "bar", "baz"]
     end
   end
+  
+  context "performing a MapReduce query" do
+    before do
+      @mr = Riak::MapReduce.new(@client).map("Riak.mapValues", :keep => true)
+    end
 
-  describe "detecting whether a body should be returned" do
-    it "should be false when the method is :head" do
-      @backend.should_not be_return_body(:head, 200, false)
+    it "should issue POST request to the mapred endpoint" do
+      @backend.should_receive(:post).with(200, "/mapred", @mr.to_json, hash_including("Content-Type" => "application/json")).and_return({:headers => {'content-type' => ["application/json"]}, :body => "[]"})
+      @backend.mapred(@mr)
     end
 
-    it "should be false when the response code is 204, 205, or 304" do
-      @backend.should_not be_return_body(:get, 204, false)
-      @backend.should_not be_return_body(:get, 205, false)
-      @backend.should_not be_return_body(:get, 304, false)
+    it "should vivify JSON responses" do
+      @backend.stub!(:post).and_return(:headers => {'content-type' => ["application/json"]}, :body => '[{"key":"value"}]')
+      @backend.mapred(@mr).should == [{"key" => "value"}]
     end
 
-    it "should be false when a streaming block was passed" do
-      @backend.should_not be_return_body(:get, 200, true)
+    it "should return the full response hash for non-JSON responses" do
+      response = {:code => 200, :headers => {'content-type' => ["text/plain"]}, :body => 'This is some text.'}
+      @backend.stub!(:post).and_return(response)
+      @backend.mapred(@mr).should == response
     end
+  end
 
-    it "should be true when the method is not head, a code other than 204, 205, or 304 was given, and there was no streaming block" do
-      [:get, :put, :post, :delete].each do |method|
-        [100,101,200,201,202,203,206,300,301,302,303,305,307,400,401,
-         402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,
-         500,501,502,503,504,505].each do |code|
-          @backend.should be_return_body(method, code, false)
-          @backend.should be_return_body(method, code.to_s, false)
-        end
-      end
+  context "getting statistics" do
+    it "should get the status URL and parse the response as JSON" do
+      @backend.should_receive(:get).with(200, "/stats", {}, {}).and_return({:body => '{"vnode_gets":20348}'})
+      @backend.stats.should == {"vnode_gets" => 20348}
     end
   end
   
-  it "should force subclasses to implement the perform method" do
-    lambda { @backend.send(:perform, :get, "/foo", {}, 200) }.should raise_error(NotImplementedError)
+  context "performing a link-walking query" do
+    before do
+      @bucket = Riak::Bucket.new(@client, "foo")
+      @object = Riak::RObject.new(@bucket, "bar")
+      @body = File.read(File.expand_path("#{File.dirname(__FILE__)}/../fixtures/multipart-with-body.txt"))
+      @specs = [Riak::WalkSpec.new(:tag => "next", :keep => true)]
+    end
+
+    it "should perform a GET request for the given object and walk specs" do
+      @backend.should_receive(:get).with(200, "/riak/", "foo", "bar", "_,next,1").and_return(:headers => {"content-type" => ["multipart/mixed; boundary=12345"]}, :body => "\n--12345\nContent-Type: multipart/mixed; boundary=09876\n\n--09876--\n\n--12345--\n")
+      @backend.link_walk(@object, @specs)
+    end
+
+    it "should parse the results into arrays of objects" do
+      @backend.should_receive(:get).and_return(:headers => {"content-type" => ["multipart/mixed; boundary=5EiMOjuGavQ2IbXAqsJPLLfJNlA"]}, :body => @body)
+      results = @backend.link_walk(@object, @specs)
+      results.should be_kind_of(Array)
+      results.first.should be_kind_of(Array)
+      obj = results.first.first
+      obj.should be_kind_of(Riak::RObject)
+      obj.content_type.should == "text/plain"
+      obj.key.should == "baz"
+      obj.bucket.should == @bucket
+    end
+
+    it "should assign the bucket for newly parsed objects" do
+      @backend.stub!(:get).and_return(:headers => {"content-type" => ["multipart/mixed; boundary=5EiMOjuGavQ2IbXAqsJPLLfJNlA"]}, :body => @body)
+      @client.should_receive(:bucket).with("foo").and_return(@bucket)
+      @backend.link_walk(@object, @specs)
+    end
   end
 end