riak-client 2.0.0 → 2.1.0

data/spec/riak/map_reduce_spec.rb

@@ -8,17 +8,17 @@ describe Riak::MapReduce do
     @mr = Riak::MapReduce.new(@client)
   end
 
-  it "should require a client" do
+  it "requires a client" do
     expect { Riak::MapReduce.new }.to raise_error
     expect { Riak::MapReduce.new(@client) }.not_to raise_error
   end
 
-  it "should initialize the inputs and query to empty arrays" do
+  it "initializes the inputs and query to empty arrays" do
     expect(@mr.inputs).to eq([])
     expect(@mr.query).to eq([])
   end
 
-  it "should yield itself when given a block on initializing" do
+  it "yields itself when given a block on initializing" do
     @mr2 = nil
     @mr = Riak::MapReduce.new(@client) do |mr|
       @mr2 = mr
@@ -27,45 +27,45 @@ describe Riak::MapReduce do
   end
 
   describe "adding inputs" do
-    it "should return self for chaining" do
+    it "returns self for chaining" do
       expect(@mr.add("foo", "bar")).to eq(@mr)
     end
 
-    it "should add bucket/key pairs to the inputs" do
+    it "adds bucket/key pairs to the inputs" do
       @mr.add("foo","bar")
       expect(@mr.inputs).to eq([["foo","bar"]])
     end
 
-    it "should add an array containing a bucket/key pair to the inputs" do
+    it "adds an array containing a bucket/key pair to the inputs" do
       @mr.add(["foo","bar"])
       expect(@mr.inputs).to eq([["foo","bar"]])
     end
 
-    it "should add an object to the inputs by its bucket and key" do
+    it "adds an object to the inputs by its bucket and key" do
       bucket = Riak::Bucket.new(@client, "foo")
       obj = Riak::RObject.new(bucket, "bar")
       @mr.add(obj)
       expect(@mr.inputs).to eq([["foo", "bar"]])
     end
 
-    it "should add an array containing a bucket/key/key-data triple to the inputs" do
+    it "adds an array containing a bucket/key/key-data triple to the inputs" do
       @mr.add(["foo","bar",1000])
       expect(@mr.inputs).to eq([["foo","bar",1000]])
     end
 
-    it "should use a bucket name as the single input" do
+    it "uses a bucket name as the single input" do
       @mr.add(Riak::Bucket.new(@client, "foo"))
       expect(@mr.inputs).to eq("foo")
       @mr.add("docs")
       expect(@mr.inputs).to eq("docs")
     end
 
-    it "should accept a list of key-filters along with a bucket" do
+    it "accepts a list of key-filters along with a bucket" do
       @mr.add("foo", [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]])
       expect(@mr.inputs).to eq({:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]})
     end
 
-    it "should add a bucket and filter list via a builder block" do
+    it "adds a bucket and filter list via a builder block" do
       @mr.filter("foo") do
         tokenize "-", 3
         string_to_int
@@ -75,17 +75,17 @@ describe Riak::MapReduce do
     end
 
     context "using secondary indexes as inputs" do
-      it "should set the inputs for equality" do
+      it "sets the inputs for equality" do
         expect(@mr.index("foo", "email_bin", "sean@basho.com")).to eq(@mr)
         expect(@mr.inputs).to eq({:bucket => "foo", :index => "email_bin", :key => "sean@basho.com"})
       end
 
-      it "should set the inputs for a range" do
+      it "sets the inputs for a range" do
         expect(@mr.index("foo", "rank_int", 10..20)).to eq(@mr)
         expect(@mr.inputs).to eq({:bucket => "foo", :index => "rank_int", :start => 10, :end => 20})
       end
 
-      it "should raise an error when given an invalid query" do
+      it "raises 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
@@ -99,29 +99,29 @@ describe Riak::MapReduce 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
+        it "adds bucket/key pairs to the inputs with bucket and key escaped" do
           @mr.add("[foo]","(bar)")
           expect(@mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
         end
 
-        it "should add an escaped array containing a bucket/key pair to the inputs" do
+        it "adds an escaped array containing a bucket/key pair to the inputs" do
           @mr.add(["[foo]","(bar)"])
           expect(@mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
         end
 
-        it "should add an object to the inputs by its escaped bucket and key" do
+        it "adds 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)
           expect(@mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
         end
 
-        it "should add an escaped array containing a bucket/key/key-data triple to the inputs" do
+        it "adds an escaped array containing a bucket/key/key-data triple to the inputs" do
           @mr.add(["[foo]","(bar)","[]()"])
           expect(@mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29","[]()"]])
         end
 
-        it "should use an escaped bucket name as the single input" do
+        it "uses an escaped bucket name as the single input" do
           @mr.add(Riak::Bucket.new(@client, "[foo]"))
           expect(@mr.inputs).to eq("%5Bfoo%5D")
           @mr.add("docs")
@@ -133,29 +133,29 @@ describe Riak::MapReduce 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
+        it "adds bucket/key pairs to the inputs with bucket and key unescaped" do
           @mr.add("[foo]","(bar)")
           expect(@mr.inputs).to eq([["[foo]","(bar)"]])
         end
 
-        it "should add an unescaped array containing a bucket/key pair to the inputs" do
+        it "adds an unescaped array containing a bucket/key pair to the inputs" do
           @mr.add(["[foo]","(bar)"])
           expect(@mr.inputs).to eq([["[foo]","(bar)"]])
         end
 
-        it "should add an object to the inputs by its unescaped bucket and key" do
+        it "adds 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)
           expect(@mr.inputs).to eq([["[foo]","(bar)"]])
         end
 
-        it "should add an unescaped array containing a bucket/key/key-data triple to the inputs" do
+        it "adds an unescaped array containing a bucket/key/key-data triple to the inputs" do
           @mr.add(["[foo]","(bar)","[]()"])
           expect(@mr.inputs).to eq([["[foo]","(bar)","[]()"]])
         end
 
-        it "should use an unescaped bucket name as the single input" do
+        it "uses an unescaped bucket name as the single input" do
           @mr.add(Riak::Bucket.new(@client, "[foo]"))
           expect(@mr.inputs).to eq("[foo]")
           @mr.add("docs")
@@ -168,29 +168,29 @@ describe Riak::MapReduce 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
+      it "adds bucket/key pairs to the inputs with bucket and key escaped" do
         @mr.add("[foo]","(bar)")
         expect(@mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
       end
 
-      it "should add an escaped array containing a bucket/key pair to the inputs" do
+      it "adds an escaped array containing a bucket/key pair to the inputs" do
         @mr.add(["[foo]","(bar)"])
         expect(@mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
       end
 
-      it "should add an object to the inputs by its escaped bucket and key" do
+      it "adds 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)
         expect(@mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
       end
 
-      it "should add an escaped array containing a bucket/key/key-data triple to the inputs" do
+      it "adds an escaped array containing a bucket/key/key-data triple to the inputs" do
         @mr.add(["[foo]","(bar)","[]()"])
         expect(@mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29","[]()"]])
       end
 
-      it "should use an escaped bucket name as the single input" do
+      it "uses an escaped bucket name as the single input" do
         @mr.add(Riak::Bucket.new(@client, "[foo]"))
         expect(@mr.inputs).to eq("%5Bfoo%5D")
         @mr.add("docs")
@@ -202,13 +202,13 @@ describe Riak::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
+      it "warns about list-keys on buckets" do
         expect(@mr).to receive(:warn).twice
         @mr.add("foo")
         @mr.add(Riak::Bucket.new(@client, "foo"))
       end
 
-      it "should warn about list-keys on key-filters" do
+      it "warns about list-keys on key-filters" do
         expect(@mr).to receive(:warn)
         @mr.filter("foo") { matches "bar" }
       end
@@ -217,11 +217,11 @@ describe Riak::MapReduce do
 
   [:map, :reduce].each do |type|
     describe "adding #{type} phases" do
-      it "should return self for chaining" do
+      it "returns self for chaining" do
         expect(@mr.send(type, "function(){}")).to eq(@mr)
       end
 
-      it "should accept a function string" do
+      it "accepts a function string" do
         @mr.send(type, "function(){}")
         expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
@@ -229,7 +229,7 @@ describe Riak::MapReduce do
         expect(phase.type).to eq(type)
       end
 
-      it "should accept a function and options" do
+      it "accepts a function and options" do
         @mr.send(type, "function(){}", :keep => true)
         expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
@@ -238,7 +238,7 @@ describe Riak::MapReduce do
         expect(phase.keep).to be_truthy
       end
 
-      it "should accept a module/function pair" do
+      it "accepts a module/function pair" do
         @mr.send(type, ["riak","mapsomething"])
         expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
@@ -247,7 +247,7 @@ describe Riak::MapReduce do
         expect(phase.language).to eq("erlang")
       end
 
-      it "should accept a module/function pair with extra options" do
+      it "accepts a module/function pair with extra options" do
         @mr.send(type, ["riak", "mapsomething"], :arg => [1000])
         expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
@@ -260,11 +260,11 @@ describe Riak::MapReduce do
   end
 
   describe "adding link phases" do
-    it "should return self for chaining" do
+    it "returns self for chaining" do
       expect(@mr.link({})).to eq(@mr)
     end
 
-    it "should accept a WalkSpec" do
+    it "accepts a WalkSpec" do
       @mr.link(Riak::WalkSpec.new(:tag => "next"))
       expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
@@ -273,7 +273,7 @@ describe Riak::MapReduce do
       expect(phase.function.tag).to eq("next")
     end
 
-    it "should accept a WalkSpec and a hash of options" do
+    it "accepts a WalkSpec and a hash of options" do
       @mr.link(Riak::WalkSpec.new(:bucket => "foo"), :keep => true)
       expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
@@ -283,7 +283,7 @@ describe Riak::MapReduce do
       expect(phase.keep).to be_truthy
     end
 
-    it "should accept a hash of options intermingled with the walk spec options" do
+    it "accepts a hash of options intermingled with the walk spec options" do
       @mr.link(:tag => "snakes", :arg => [1000])
       expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
@@ -294,34 +294,34 @@ describe Riak::MapReduce do
   end
 
   describe "converting to JSON for the job" do
-    it "should include the inputs and query keys" do
+    it "includes the inputs and query keys" do
       expect(@mr.to_json).to match(/"inputs":/)
     end
 
-    it "should map phases to their JSON equivalents" do
+    it "maps phases to their JSON equivalents" do
       phase = Riak::MapReduce::Phase.new(:type => :map, :function => "function(){}")
       @mr.query << phase
       expect(@mr.to_json).to include('"source":"function(){}"')
       expect(@mr.to_json).to include('"query":[{"map":{')
     end
 
-    it "should emit only the bucket name when the input is the whole bucket" do
+    it "emits only the bucket name when the input is the whole bucket" do
       @mr.add("foo")
       expect(@mr.to_json).to include('"inputs":"foo"')
     end
 
-    it "should emit an array of inputs when there are multiple inputs" do
+    it "emits an array of inputs when there are multiple inputs" do
       @mr.add("foo","bar",1000).add("foo","baz")
       expect(@mr.to_json).to include('"inputs":[["foo","bar",1000],["foo","baz"]]')
     end
 
-    it "should add the timeout value when set" do
+    it "adds the timeout value when set" do
       @mr.timeout(50000)
       expect(@mr.to_json).to include('"timeout":50000')
     end
   end
 
-  it "should return self from setting the timeout" do
+  it "returns self from setting the timeout" do
     expect(@mr.timeout(5000)).to eq(@mr)
   end
 
@@ -330,19 +330,19 @@ describe Riak::MapReduce do
       @mr.map("Riak.mapValues",:keep => true)
     end
 
-    it "should submit the query to the backend" do
+    it "submits the query to the backend" do
       expect(@backend).to receive(:mapred).with(@mr).and_return([])
       expect(@mr.run).to eq([])
     end
 
-    it "should pass the given block to the backend for streaming" do
+    it "passes the given block to the backend for streaming" do
       arr = []
       expect(@backend).to receive(:mapred).with(@mr).and_yield("foo").and_yield("bar")
       @mr.run {|v| arr << v }
       expect(arr).to eq(["foo", "bar"])
     end
 
-    it "should interpret failed requests with JSON content-types as map reduce errors" do
+    it "interprets failed requests with JSON content-types as map reduce errors" do
       allow(@backend).to receive(:mapred).
         and_raise(Riak::ProtobuffsFailedRequest.new(:server_error, '{"error":"syntax error"}'))
       expect{ @mr.run }.to raise_error(Riak::MapReduceError)
@@ -355,7 +355,7 @@ describe Riak::MapReduce do
       end
     end
 
-    it "should re-raise non-JSON error responses" do
+    it "re-raises non-JSON error responses" do
       allow(@backend).to receive(:mapred).
         and_raise(Riak::ProtobuffsFailedRequest.new(:server_error, 'Oops, you bwoke it.'))
       expect { @mr.run }.to raise_error(Riak::FailedRequest)

data/spec/riak/multiget_spec.rb

@@ -8,13 +8,13 @@ describe Riak::Multiget do
   end
 
   describe "initialization" do
-    it "should accept a client and an array of bucket/key pairs" do
+    it "accepts a client and an array of bucket/key pairs" do
       expect { Riak::Multiget.new(@client, @pairs) }.not_to raise_error
     end
   end
 
   describe "operation" do
-    it "should fetch both keys from the bucket" do
+    it "fetches both keys from the bucket" do
       expect(@bucket).to receive(:[]).with('key1')
       expect(@bucket).to receive(:[]).with('key2')
 
@@ -23,7 +23,7 @@ describe Riak::Multiget do
       @multiget.wait_for_finish
     end
 
-    it "should asynchronously fetch" do
+    it "fetches asynchronously" do
       # make fetches slow
       @slow_mtx = Mutex.new
       @slow_mtx.lock
@@ -50,7 +50,7 @@ describe Riak::Multiget do
       expect(@results).to be_a Hash
     end
 
-    it "should not die when objects aren't found" do
+    it "returns found objects when only some objects are found" do
       expect(@bucket).to receive(:[]).
         with('key1').
         and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, "not found"))
@@ -67,7 +67,7 @@ describe Riak::Multiget do
   end
 
   describe "results" do
-    it "should return a hash of pairs to values" do
+    it "returns a hash of pairs to values" do
       expect(@bucket).to receive(:[]).with('key1')
       expect(@bucket).to receive(:[]).with('key2')
       

data/spec/riak/node_spec.rb

@@ -7,18 +7,18 @@ describe Riak::Client::Node do
   end
 
   describe 'when initializing' do
-    it 'should default to the local interface on port 8087' do
+    it 'defaults to the local interface on port 8087' do
       node = Riak::Client::Node.new @client
       expect(node.host).to eq('127.0.0.1')
       expect(node.pb_port).to eq(8087)
     end
 
-    it 'should accept a host' do
+    it 'accepts a host' do
       node = Riak::Client::Node.new(@client, :host => 'riak.basho.com')
       expect(node.host).to eq("riak.basho.com")
     end
 
-    it 'should accept a Protobuffs port' do
+    it 'accepts a Protobuffs port' do
       node = Riak::Client::Node.new @client, :pb_port => 9000
       expect(node.pb_port).to eq(9000)
     end

data/spec/riak/robject_spec.rb

@@ -7,34 +7,34 @@ describe Riak::RObject do
   end
 
   describe "initialization" do
-    it "should set the bucket" do
+    it "sets the bucket" do
       @object = Riak::RObject.new(@bucket)
       expect(@object.bucket).to eq(@bucket)
     end
 
-    it "should set the key" do
+    it "sets the key" do
       @object = Riak::RObject.new(@bucket, "bar")
       expect(@object.key).to eq("bar")
     end
 
-    it "should initialize the links to an empty set" do
+    it "initializes the links to an empty set" do
       @object = Riak::RObject.new(@bucket, "bar")
       expect(@object.links).to eq(Set.new)
     end
 
-    it "should initialize the meta to an empty hash" do
+    it "initializes the meta to an empty hash" do
       @object = Riak::RObject.new(@bucket, "bar")
       expect(@object.meta).to eq({})
     end
 
-    it "should initialize indexes to an empty hash with a Set for the default value" do
+    it "initializes indexes to an empty hash with a Set for the default value" do
       @object = Riak::RObject.new(@bucket, "bar")
       expect(@object.indexes).to be_kind_of(Hash)
       expect(@object.indexes).to be_empty
       expect(@object.indexes['foo_bin']).to be_kind_of(Set)
     end
 
-    it "should yield itself to a given block" do
+    it "yields itself to a given block" do
       Riak::RObject.new(@bucket, "bar") do |r|
         expect(r.key).to eq("bar")
       end
@@ -73,19 +73,19 @@ describe Riak::RObject do
           @object.data = { 'some' => 'data' }
         end
 
-        it "should reset unserialized forms when stored" do
+        it "resets unserialized forms when stored" do
           @object.raw_data = value = '{ "raw": "json" }'
 
           expect(@object.raw_data).to eq(value)
           expect(@object.data).to eq({ "raw" => "json" })
         end
 
-        it "should lazily serialize when read" do
+        it "lazily serializes when read" do
           expect(@object.raw_data).to eq('{"some":"data"}')
         end
       end
 
-      it "should not unnecessarily marshal/demarshal" do
+      it "only marshal/demarshals when necessary" do
         expect(@object).not_to receive(:serialize)
         expect(@object).not_to receive(:deserialize)
         @object.raw_data = value = "{not even valid json!}}"
@@ -99,13 +99,13 @@ describe Riak::RObject do
           @object.raw_data = '{"some":"data"}'
         end
 
-        it "should reset previously stored raw data" do
+        it "resets previously stored raw data" do
           @object.data = value = { "new" => "data" }
           expect(@object.raw_data).to eq('{"new":"data"}')
           expect(@object.data).to eq(value)
         end
 
-        it "should lazily deserialize when read" do
+        it "lazily deserializes when read" do
           expect(@object.data).to eq({ "some" => "data" })
         end
 
@@ -118,7 +118,8 @@ describe Riak::RObject do
             expect(@object.data).to eq('deserialized')
           end
 
-          it 'does not allow it to be assigned directly to data since it should be assigned to raw_data instead' do
+          it 'does not allow it to be assigned directly to data' do
+            # it should be assigned to raw_data instead
             expect {
               @object.data = io_object
             }.to raise_error(ArgumentError)
@@ -126,7 +127,7 @@ describe Riak::RObject do
         end
       end
 
-      it "should not unnecessarily marshal/demarshal" do
+      it "only marshal/demarshals when necessary" do
         expect(@object).not_to receive(:serialize)
         expect(@object).not_to receive(:deserialize)
         @object.data = value = { "some" => "data" }
@@ -166,55 +167,55 @@ describe Riak::RObject do
       expect(@object).to be_kind_of(Riak::RObject)
     end
 
-    it "should load the content type" do
+    it "loads the content type" do
       expect(@object.content_type).to eq("application/json")
     end
 
-    it "should load the body data" do
+    it "loads the body data" do
       expect(@object.data).to be_present
     end
 
-    it "should deserialize the body data" do
+    it "deserializes the body data" do
       expect(@object.data).to eq({"email" => "mail@test.com", "_type" => "User"})
     end
 
-    it "should set the vclock" do
+    it "sets the vclock" do
       expect(@object.vclock).to eq("a85hYGBgzmDKBVIsCfs+fc9gSN9wlA8q/hKosDpIOAsA")
     end
 
-    it "should load and parse links" do
+    it "loads and parse links" do
       expect(@object.links.size).to eq(1)
       expect(@object.links.first.url).to eq("/riak/addresses/A2cbUQ2KEMbeyWGtdz97LoTi1DN")
       expect(@object.links.first.rel).to eq("home_address")
     end
 
-    it "should load and parse indexes" do
+    it "loads and parse indexes" do
       expect(@object.indexes.size).to eq(2)
       expect(@object.indexes['email_bin'].size).to eq(2)
       expect(@object.indexes['rank_int'].size).to eq(1)
     end
 
-    it "should set the ETag" do
+    it "sets the ETag" do
       expect(@object.etag).to eq("5bnavU3rrubcxLI8EvFXhB")
     end
 
-    it "should set modified date" do
+    it "sets modified date" do
       expect(@object.last_modified.to_i).to eq(Time.httpdate("Mon, 12 Jul 2010 21:37:43 GMT").to_i)
     end
 
-    it "should load meta information" do
+    it "loads meta information" do
       expect(@object.meta["King-Of-Robots"]).to eq(["I"])
     end
 
-    it "should set the key" do
+    it "sets the key" do
       expect(@object.key).to eq("A2IbUQ2KEMbe4WGtdL97LoTi1DN[(\\/)]")
     end
 
-    it "should not set conflict when there is none" do
+    it "doesn't set conflict when there is none" do
       expect(@object.conflict?).to be_falsey
     end
 
-    it 'should return [RContent] for siblings' do
+    it 'returns [RContent] for siblings' do
       expect(@object.siblings).to eq([@object.content])
     end
 
@@ -234,27 +235,27 @@ describe Riak::RObject do
         @object = Riak::RObject.load_from_mapreduce( @client, response ).first
       end
 
-      it "should expose siblings" do
+      it "exposes siblings" do
         expect(@object.siblings.size).to eq(2)
         expect(@object.siblings[0].etag).to eq("5bnavU3rrubcxLI8EvFXhB")
         expect(@object.siblings[1].etag).to eq("7jDZLdu0fIj2iRsjGD8qq8")
       end
 
-      it "should be in conflict" do
+      it "raises the conflict? flag when in conflict" do
         expect { @object.data }.to raise_error(Riak::Conflict)
         expect(@object).to be_conflict
       end
     end
   end
 
-  it "should not allow duplicate links" do
+  it "doesn't allow duplicate links" do
     @object = Riak::RObject.new(@bucket, "foo")
     @object.links << Riak::Link.new("/riak/foo/baz", "next")
     @object.links << Riak::Link.new("/riak/foo/baz", "next")
     expect(@object.links.length).to eq(1)
   end
 
-  it "should allow mass-overwriting indexes while preserving default behavior" do
+  it "allows mass-overwriting indexes while preserving default behavior" do
     @object = described_class.new(@bucket, 'foo')
     @object.indexes = {"ts_int" => [12345], "foo_bin" => "bar"}
     expect(@object.indexes['ts_int']).to eq(Set.new([12345]))
@@ -272,21 +273,21 @@ describe Riak::RObject do
       # @headers = @object.store_headers
     end
 
-    it "should raise an error when the content_type is blank" do
+    it "raises an error when the content_type is blank" do
       expect { @object.content_type = nil; @object.store }.to raise_error(ArgumentError)
       expect { @object.content_type = "   "; @object.store }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error when given an empty string as key" do
+    it "raises an error when given an empty string as key" do
       expect { @object.key = ''; @object.store }.to raise_error(ArgumentError)
     end
 
-    it "should pass along quorum parameters and returnbody to the backend" do
+    it "passes quorum parameters and returnbody to the backend" do
       expect(@backend).to receive(:store_object).with(@object, :returnbody => false, :w => 3, :dw => 2).and_return(true)
       @object.store(:returnbody => false, :w => 3, :dw => 2)
     end
 
-    it "should raise an error if the object is in conflict" do
+    it "raises an error if the object is in conflict" do
       @object.siblings << Riak::RContent.new(@object)
       expect { @object.store }.to raise_error(Riak::Conflict)
     end
@@ -300,29 +301,29 @@ describe Riak::RObject do
       @object.vclock = "somereallylongstring"
     end
 
-    it "should return without requesting if the key is blank" do
+    it "returns without requesting if the key is blank" do
       @object.key = nil
       expect(@backend).not_to receive(:reload_object)
       @object.reload
     end
 
-    it "should return without requesting if the vclock is blank" do
+    it "returns without requesting if the vclock is blank" do
       @object.vclock = nil
       expect(@backend).not_to receive(:reload_object)
       @object.reload
     end
 
-    it "should reload the object if the key is present" do
+    it "reloads the object if the key is present" do
       expect(@backend).to receive(:reload_object).with(@object, {}).and_return(@object)
       @object.reload
     end
 
-    it "should pass along the requested R quorum" do
+    it "passes the requested R quorum to the backend" do
       expect(@backend).to 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
+    it "disables matching conditions if the key is present and the :force option is given" do
       expect(@backend).to receive(:reload_object) do |obj, _|
         expect(obj.etag).to be_nil
         expect(obj.last_modified).to be_nil
@@ -339,42 +340,42 @@ describe Riak::RObject do
       @object = Riak::RObject.new(@bucket, "bar")
     end
 
-    it "should make a DELETE request to the Riak server and freeze the object" do
+    it "makes a DELETE request to the Riak server and freeze the object" do
       expect(@backend).to receive(:delete_object).with(@bucket, "bar", {})
       @object.delete
       expect(@object).to be_frozen
     end
 
-    it "should do nothing when the key is blank" do
+    it "does nothing when the key is blank" do
       expect(@backend).not_to receive(:delete_object)
       @object.key = nil
       @object.delete
     end
 
-    it "should pass through a failed request exception" do
+    it "raises a failed request exception when the backend returns a server error" do
       expect(@backend).to receive(:delete_object).
         and_raise(Riak::ProtobuffsFailedRequest.new(:server_error, "server error"))
       expect { @object.delete }.to raise_error(Riak::FailedRequest)
     end
 
-    it "should send the vector clock if present" do
+    it "sends the vector clock to the backend if present" do
       @object.vclock = "somevclock"
       expect(@backend).to receive(:delete_object).with(@bucket, "bar", {:vclock => "somevclock"})
       @object.delete
     end
   end
 
-  it "should not convert to link without a tag" do
+  it "doesn't convert to link without a tag" do
     @object = Riak::RObject.new(@bucket, "bar")
     expect { @object.to_link }.to raise_error
   end
 
-  it "should convert to a link having the same url and a supplied tag" do
+  it "converts to a link having the same url and a supplied tag" do
     @object = Riak::RObject.new(@bucket, "bar")
     expect(@object.to_link("next")).to eq(Riak::Link.new("/riak/foo/bar", "next"))
   end
 
-  it "should escape the bucket and key when converting to a link" do
+  it "escapes the bucket and key when converting to a link" do
     @object = Riak::RObject.new(@bucket, "deep/path")
     expect(@bucket).to receive(:name).and_return("bucket spaces")
     expect(@object.to_link("bar").url).to eq("/riak/bucket%20spaces/deep%2Fpath")