riak-client 0.9.8 → 1.0.0.beta

data/spec/riak/link_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::Link do
   describe "parsing a link header" do
@@ -39,12 +26,26 @@ describe Riak::Link do
       result[0].bucket.should be_nil
       result[0].key.should be_nil
     end
+
+    it "should parse the Riak 1.0 URL scheme" do
+      result = Riak::Link.parse('</buckets/b/keys/k>; riaktag="tag"').first
+      result.bucket.should == 'b'
+      result.key.should == 'k'
+      result.tag.should == 'tag'
+    end
   end
 
-  it "should convert to a string appropriate for use in the Link header" do
-    Riak::Link.new("/riak/foo", "up").to_s.should == '</riak/foo>; riaktag="up"'
-    Riak::Link.new("/riak/foo/bar", "next").to_s.should == '</riak/foo/bar>; riaktag="next"'
-    Riak::Link.new("/riak", "riak_kv_wm_raw").to_s.should == '</riak>; riaktag="riak_kv_wm_raw"'
+  context "converting to a string" do
+    it "should convert to a string appropriate for use in the Link header" do
+      Riak::Link.new("/riak/foo", "up").to_s.should == '</riak/foo>; riaktag="up"'
+      Riak::Link.new("/riak/foo/bar", "next").to_s.should == '</riak/foo/bar>; riaktag="next"'
+      Riak::Link.new("/riak", "riak_kv_wm_raw").to_s.should == '</riak>; riaktag="riak_kv_wm_raw"'
+    end
+
+    it "should convert to a string using the new URL scheme" do
+      Riak::Link.new("bucket", "key", "tag").to_s(true).should == '</buckets/bucket/keys/key>; riaktag="tag"'
+      Riak::Link.parse('</riak/bucket/key>; riaktag="tag"').first.to_s(true).should == '</buckets/bucket/keys/key>; riaktag="tag"'
+    end
   end
 
   it "should convert to a walk spec when pointing to an object" do

data/spec/riak/map_reduce/filter_builder_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::MapReduce::FilterBuilder do
   subject { Riak::MapReduce::FilterBuilder.new }

data/spec/riak/map_reduce/phase_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::MapReduce::Phase do
   before :each do

data/spec/riak/map_reduce_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::MapReduce do
   before :each do
@@ -49,21 +36,11 @@ describe Riak::MapReduce do
       @mr.inputs.should == [["foo","bar"]]
     end
 
-    it "should add bucket/key pairs to the inputs" do
-      @mr.add("[foo]","(bar)")
-      @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
-    end
-
     it "should add an array containing a bucket/key pair to the inputs" do
       @mr.add(["foo","bar"])
       @mr.inputs.should == [["foo","bar"]]
     end
 
-    it "should add an escaped array containing a bucket/key pair to the inputs" do
-      @mr.add(["[foo]","(bar)"])
-      @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
-    end
-
     it "should add an object to the inputs by its bucket and key" do
       bucket = Riak::Bucket.new(@client, "foo")
       obj = Riak::RObject.new(bucket, "bar")
@@ -71,23 +48,11 @@ describe Riak::MapReduce do
       @mr.inputs.should == [["foo", "bar"]]
     end
 
-    it "should add an object to the inputs by its escaped bucket and key" do
-      bucket = Riak::Bucket.new(@client, "[foo]")
-      obj = Riak::RObject.new(bucket, "(bar)")
-      @mr.add(obj)
-      @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29"]]
-    end
-
     it "should add an array containing a bucket/key/key-data triple to the inputs" do
       @mr.add(["foo","bar",1000])
       @mr.inputs.should == [["foo","bar",1000]]
     end
 
-    it "should add an escaped array containing a bucket/key/key-data triple to the inputs" do
-      @mr.add(["[foo]","(bar)","[]()"])
-      @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29","[]()"]]
-    end
-
     it "should use a bucket name as the single input" do
       @mr.add(Riak::Bucket.new(@client, "foo"))
       @mr.inputs.should == "foo"
@@ -95,13 +60,6 @@ describe Riak::MapReduce do
       @mr.inputs.should == "docs"
     end
 
-    it "should use an escaped bucket name as the single input" do
-      @mr.add(Riak::Bucket.new(@client, "[foo]"))
-      @mr.inputs.should == "%5Bfoo%5D"
-      @mr.add("docs")
-      @mr.inputs.should == "docs"
-    end
-
     it "should accept a list of key-filters along with a bucket" do
       @mr.add("foo", [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]])
       @mr.inputs.should == {:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
@@ -115,6 +73,146 @@ describe Riak::MapReduce do
       end
       @mr.inputs.should == {:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]}
     end
+
+    context "using secondary indexes as inputs" do
+      it "should set the inputs for equality" do
+        @mr.index("foo", "email_bin", "sean@basho.com").should == @mr
+        @mr.inputs.should == {:bucket => "foo", :index => "email_bin", :key => "sean@basho.com"}
+      end
+
+      it "should set the inputs for a range" do
+        @mr.index("foo", "rank_int", 10..20).should == @mr
+        @mr.inputs.should == {:bucket => "foo", :index => "rank_int", :start => 10, :end => 20}
+      end
+
+      it "should raise an error when given an invalid query" do
+        expect { @mr.index("foo", "rank_int", 1.0348) }.to raise_error(ArgumentError)
+        expect { @mr.index("foo", "rank_int", Range.new(1.03, 1.05)) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "escaping" do
+      before { @oldesc, Riak.escaper = Riak.escaper, CGI }
+      after { Riak.escaper = @oldesc }
+
+      context "when url_decoding is false" do
+        before { @urldecode, Riak.url_decoding = Riak.url_decoding, false }
+        after { Riak.url_decoding = @urldecode }
+
+        it "should add bucket/key pairs to the inputs with bucket and key escaped" do
+          @mr.add("[foo]","(bar)")
+          @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+        end
+
+        it "should add an escaped array containing a bucket/key pair to the inputs" do
+          @mr.add(["[foo]","(bar)"])
+          @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+        end
+
+        it "should add an object to the inputs by its escaped bucket and key" do
+          bucket = Riak::Bucket.new(@client, "[foo]")
+          obj = Riak::RObject.new(bucket, "(bar)")
+          @mr.add(obj)
+          @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29"]]
+        end
+
+        it "should add an escaped array containing a bucket/key/key-data triple to the inputs" do
+          @mr.add(["[foo]","(bar)","[]()"])
+          @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29","[]()"]]
+        end
+
+        it "should use an escaped bucket name as the single input" do
+          @mr.add(Riak::Bucket.new(@client, "[foo]"))
+          @mr.inputs.should == "%5Bfoo%5D"
+          @mr.add("docs")
+          @mr.inputs.should == "docs"
+        end
+      end
+
+      context "when url_decoding is true" do
+        before { @urldecode, Riak.url_decoding = Riak.url_decoding, true }
+        after { Riak.url_decoding = @urldecode }
+
+        it "should add bucket/key pairs to the inputs with bucket and key unescaped" do
+          @mr.add("[foo]","(bar)")
+          @mr.inputs.should == [["[foo]","(bar)"]]
+        end
+
+        it "should add an unescaped array containing a bucket/key pair to the inputs" do
+          @mr.add(["[foo]","(bar)"])
+          @mr.inputs.should == [["[foo]","(bar)"]]
+        end
+
+        it "should add an object to the inputs by its unescaped bucket and key" do
+          bucket = Riak::Bucket.new(@client, "[foo]")
+          obj = Riak::RObject.new(bucket, "(bar)")
+          @mr.add(obj)
+          @mr.inputs.should == [["[foo]","(bar)"]]
+        end
+
+        it "should add an unescaped array containing a bucket/key/key-data triple to the inputs" do
+          @mr.add(["[foo]","(bar)","[]()"])
+          @mr.inputs.should == [["[foo]","(bar)","[]()"]]
+        end
+
+        it "should use an unescaped bucket name as the single input" do
+          @mr.add(Riak::Bucket.new(@client, "[foo]"))
+          @mr.inputs.should == "[foo]"
+          @mr.add("docs")
+          @mr.inputs.should == "docs"
+        end
+      end
+    end
+
+    context "escaping" do
+      before { @oldesc, Riak.escaper = Riak.escaper, CGI }
+      after { Riak.escaper = @oldesc }
+
+      it "should add bucket/key pairs to the inputs with bucket and key escaped" do
+        @mr.add("[foo]","(bar)")
+        @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+      end
+
+      it "should add an escaped array containing a bucket/key pair to the inputs" do
+        @mr.add(["[foo]","(bar)"])
+        @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+      end
+
+      it "should add an object to the inputs by its escaped bucket and key" do
+        bucket = Riak::Bucket.new(@client, "[foo]")
+        obj = Riak::RObject.new(bucket, "(bar)")
+        @mr.add(obj)
+        @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29"]]
+      end
+
+      it "should add an escaped array containing a bucket/key/key-data triple to the inputs" do
+        @mr.add(["[foo]","(bar)","[]()"])
+        @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29","[]()"]]
+      end
+
+      it "should use an escaped bucket name as the single input" do
+        @mr.add(Riak::Bucket.new(@client, "[foo]"))
+        @mr.inputs.should == "%5Bfoo%5D"
+        @mr.add("docs")
+        @mr.inputs.should == "docs"
+      end
+    end
+
+    context "when adding an input that will result in full-bucket mapreduce" do
+      before { Riak.disable_list_keys_warnings = false }
+      after { Riak.disable_list_keys_warnings = true }
+
+      it "should warn about list-keys on buckets" do
+        @mr.should_receive(:warn).twice
+        @mr.add("foo")
+        @mr.add(Riak::Bucket.new(@client, "foo"))
+      end
+
+      it "should warn about list-keys on key-filters" do
+        @mr.should_receive(:warn)
+        @mr.filter("foo") { matches "bar" }
+      end
+    end
   end
 
   [:map, :reduce].each do |type|

data/spec/riak/multipart_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 do
   it "should extract the boundary string from a header value" do

data/spec/riak/net_http_backend_spec.rb

@@ -1,18 +1,5 @@
-# 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::Client::NetHTTPBackend do
   before :each do
     @client = Riak::Client.new(:http_backend => :NetHTTP)

data/spec/riak/robject_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::RObject do
   before :each do
@@ -40,6 +27,13 @@ describe Riak::RObject do
       @object.meta.should == {}
     end
 
+    it "should initialize indexes to an empty hash with a Set for the default value" do
+      @object = Riak::RObject.new(@bucket, "bar")
+      @object.indexes.should be_kind_of(Hash)
+      @object.indexes.should be_empty
+      @object.indexes['foo_bin'].should be_kind_of(Set)
+    end
+
     it "should yield itself to a given block" do
       Riak::RObject.new(@bucket, "bar") do |r|
         r.key.should == "bar"
@@ -52,80 +46,18 @@ describe Riak::RObject do
       @object = Riak::RObject.new(@bucket, "bar")
     end
 
-    it "should change the data into a string by default when serializing" do
-      @object.serialize("foo").should == "foo"
-      @object.serialize(2).should == "2"
-    end
-
-    it "should not change the data when it is an IO" do
-      file = File.open("#{File.dirname(__FILE__)}/../fixtures/cat.jpg", "r")
-      file.should_not_receive(:to_s)
-      @object.serialize(file).should == file
+    it 'delegates #serialize to the appropriate serializer for the content type' do
+      @object.content_type = 'text/plain'
+      Riak::Serializers.should respond_to(:serialize).with(2).arguments
+      Riak::Serializers.should_receive(:serialize).with('text/plain', "foo").and_return("serialized foo")
+      @object.serialize("foo").should == "serialized foo"
     end
 
-    it "should not modify the data by default when deserializing" do
-      @object.deserialize("foo").should == "foo"
-    end
-
-    describe "when the content type is YAML" do
-      before :each do
-        @object.content_type = "text/x-yaml"
-      end
-
-      it "should serialize into a YAML stream" do
-        @object.serialize({"foo" => "bar"}).should == YAML.dump({"foo" => "bar"})
-      end
-
-      it "should deserialize a YAML stream" do
-        @object.deserialize(YAML.dump({"foo" => "bar"})).should == {"foo" => "bar"}
-      end
-    end
-
-    describe "when the content type is JSON" do
-      before :each do
-        @object.content_type = "application/json"
-      end
-
-      it "should serialize into a JSON blob" do
-        @object.serialize({"foo" => "bar"}).should == '{"foo":"bar"}'
-        @object.serialize([1,2,3]).should == "[1,2,3]"
-      end
-
-      it "should deserialize a JSON blob" do
-        @object.deserialize('{"foo":"bar"}').should == {"foo" => "bar"}
-        @object.deserialize('[1,2,3]').should == [1,2,3]
-      end
-
-      it "should respect 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)
-        lambda { @object.serialize(h) }.should_not raise_error
-        lambda { @object.deserialize(s) }.should_not raise_error
-      end
-    end
-
-    describe "when the content type is application/x-ruby-marshal" do
-      before :each do
-        @object.content_type = "application/x-ruby-marshal"
-        @payload = Marshal.dump({"foo" => "bar"})
-      end
-
-      it "should dump via Marshal" do
-        @object.serialize({"foo" => "bar"}).should == @payload
-      end
-
-      it "should load from Marshal" do
-        @object.deserialize(@payload).should == {"foo" => "bar"}
-      end
+    it 'delegates #deserialize to the appropriate serializer for the content type' do
+      @object.content_type = 'text/plain'
+      Riak::Serializers.should respond_to(:deserialize).with(2).arguments
+      Riak::Serializers.should_receive(:deserialize).with('text/plain', "foo").and_return("deserialized foo")
+      @object.deserialize("foo").should == "deserialized foo"
     end
   end
 
@@ -138,7 +70,7 @@ describe Riak::RObject do
     describe "for raw data" do
       describe "when unserialized data was already provided" do
         before do
-          @object.data = { :some => :data }
+          @object.data = { 'some' => 'data' }
         end
 
         it "should reset unserialized forms when stored" do
@@ -176,6 +108,22 @@ describe Riak::RObject do
         it "should lazily deserialize when read" do
           @object.data.should == { "some" => "data" }
         end
+
+        context 'for an IO-like object' do
+          let(:io_object) { stub(:read => 'the io object') }
+
+          it 'reads the object before deserializing it' do
+            @object.should_receive(:deserialize).with('the io object').and_return('deserialized')
+            @object.raw_data = io_object
+            @object.data.should == 'deserialized'
+          end
+
+          it 'does not allow it to be assigned directly to data since it should be assigned to raw_data instead' do
+            expect {
+              @object.data = io_object
+            }.to raise_error(ArgumentError)
+          end
+        end
       end
 
       it "should not unnecessarily marshal/demarshal" do
@@ -202,7 +150,12 @@ describe Riak::RObject do
                                             "X-Riak-VTag"=>"5bnavU3rrubcxLI8EvFXhB",
                                             "content-type"=>"application/json",
                                             "X-Riak-Last-Modified"=>"Mon, 12 Jul 2010 21:37:43 GMT",
-                                            "X-Riak-Meta"=>{"X-Riak-Meta-King-Of-Robots"=>"I"}},
+                                            "X-Riak-Meta"=>{"X-Riak-Meta-King-Of-Robots"=>"I"},
+                                            "index" => {
+                                              "email_bin" => ["sean@basho.com","seancribbs@gmail.com"],
+                                              "rank_int" => 50
+                                            }
+                                          },
                                           "data"=>
                                           "{\"email\":\"mail@test.com\",\"_type\":\"User\"}"
                                         }
@@ -235,6 +188,12 @@ describe Riak::RObject do
       @object.links.first.rel.should == "home_address"
     end
 
+    it "should load and parse indexes" do
+      @object.indexes.should have(2).items
+      @object.indexes['email_bin'].should have(2).items
+      @object.indexes['rank_int'].should have(1).item
+    end
+
     it "should set the ETag" do
       @object.etag.should == "5bnavU3rrubcxLI8EvFXhB"
     end
@@ -311,7 +270,7 @@ describe Riak::RObject do
     end
 
     it "should pass along quorum parameters and returnbody to the backend" do
-      @backend.should_receive(:store_object).with(@object, false, 3, 2).and_return(true)
+      @backend.should_receive(:store_object).with(@object, :returnbody => false, :w => 3, :dw => 2).and_return(true)
       @object.store(:returnbody => false, :w => 3, :dw => 2)
     end
   end
@@ -337,15 +296,15 @@ describe Riak::RObject do
     end
 
     it "should reload the object if the key is present" do
-      @backend.should_receive(:reload_object).with(@object, nil).and_return(@object)
+      @backend.should_receive(:reload_object).with(@object, {}).and_return(@object)
       @object.reload
     end
 
     it "should pass along the requested R quorum" do
-      @backend.should_receive(:reload_object).with(@object, 2).and_return(@object)
+      @backend.should_receive(:reload_object).with(@object, :r => 2).and_return(@object)
       @object.reload :r => 2
     end
-    
+
     it "should disable matching conditions if the key is present and the :force option is given" do
       @backend.should_receive(:reload_object) do |obj, _|
         obj.etag.should be_nil
@@ -378,7 +337,7 @@ describe Riak::RObject do
     end
 
     it "should make a DELETE request to the Riak server and freeze the object" do
-      @backend.should_receive(:delete_object).with(@bucket, "bar", nil)
+      @backend.should_receive(:delete_object).with(@bucket, "bar", {})
       @object.delete
       @object.should be_frozen
     end
@@ -393,6 +352,12 @@ describe Riak::RObject do
       @backend.should_receive(:delete_object).and_raise(Riak::HTTPFailedRequest.new(:delete, [204,404], 500, {}, ""))
       lambda { @object.delete }.should raise_error(Riak::FailedRequest)
     end
+
+    it "should send the vector clock if present" do
+      @object.vclock = "somevclock"
+      @backend.should_receive(:delete_object).with(@bucket, "bar", {:vclock => "somevclock"})
+      @object.delete
+    end
   end
 
   it "should not convert to link without a tag" do
@@ -411,9 +376,76 @@ describe Riak::RObject do
     @object.to_link("bar").url.should == "/riak/bucket%20spaces/deep%2Fpath"
   end
 
-  it "should provide a useful inspect output even when the key is nil" do
-    @object = Riak::RObject.new(@bucket)
-    lambda { @object.inspect }.should_not raise_error
-    @object.inspect.should be_kind_of(String)
+  describe "#inspect" do
+    let(:object) { Riak::RObject.new(@bucket) }
+
+    it "provides useful output even when the key is nil" do
+      expect { object.inspect }.not_to raise_error
+      object.inspect.should be_kind_of(String)
+    end
+
+    it 'uses the serializer output in inspect' do
+      object.raw_data = { 'a' => 7 }
+      object.content_type = 'inspect/type'
+      Riak::Serializers['inspect/type'] = Object.new.tap do |o|
+        def o.load(object); "serialize for inspect"; end
+      end
+
+      object.inspect.should =~ /serialize for inspect/
+    end
+  end
+
+  describe '.on_conflict' do
+    it 'adds the hook to the list of on conflict hooks' do
+      hook_run = false
+      described_class.on_conflict_hooks.should be_empty
+      described_class.on_conflict { hook_run = true }
+      described_class.on_conflict_hooks.size.should == 1
+      described_class.on_conflict_hooks.first.call
+      hook_run.should == true
+    end
+  end
+
+  describe '#attempt_conflict_resolution' do
+    let(:conflicted_robject) { Riak::RObject.new(@bucket, "conflicted") { |r| r.conflict = true } }
+    let(:resolved_robject) { Riak::RObject.new(@bucket, "resolved") }
+    let(:invoked_resolvers) { [] }
+    let(:resolver_1) { lambda { |r| invoked_resolvers << :resolver_1; nil } }
+    let(:resolver_2) { lambda { |r| invoked_resolvers << :resolver_2; :not_an_robject } }
+    let(:resolver_3) { lambda { |r| invoked_resolvers << :resolver_3; r } }
+    let(:resolver_4) { lambda { |r| invoked_resolvers << :resolver_4; resolved_robject } }
+
+    before(:each) do
+      described_class.on_conflict(&resolver_1)
+      described_class.on_conflict(&resolver_2)
+    end
+
+    it 'calls each resolver until one of them returns an robject' do
+      described_class.on_conflict(&resolver_3)
+      described_class.on_conflict(&resolver_4)
+      conflicted_robject.attempt_conflict_resolution
+      invoked_resolvers.should == [:resolver_1, :resolver_2, :resolver_3]
+    end
+
+    it 'returns the robject returned by the last invoked resolver' do
+      described_class.on_conflict(&resolver_4)
+      conflicted_robject.attempt_conflict_resolution.should be(resolved_robject)
+    end
+
+    it 'allows the resolver to return the original robject' do
+      described_class.on_conflict(&resolver_3)
+      conflicted_robject.attempt_conflict_resolution.should be(conflicted_robject)
+    end
+
+    it 'returns the robject and does not call any resolvers if the robject is not in conflict' do
+      resolved_robject.attempt_conflict_resolution.should be(resolved_robject)
+      invoked_resolvers.should == []
+    end
+
+    it 'returns the original robject if none of the resolvers returns an robject' do
+      conflicted_robject.attempt_conflict_resolution.should be(conflicted_robject)
+      invoked_resolvers.should == [:resolver_1, :resolver_2]
+    end
   end
 end
+