riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/index_collection_spec.rb

@@ -6,17 +6,17 @@ describe Riak::IndexCollection do
       @input = {
         'keys' => %w{first second third}
       }.to_json
-      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
-      %w{first second third}.should == @coll
+      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
+      expect(%w{first second third}).to eq(@coll)
     end
     it "should accept a list of keys and a continuation" do
       @input = {
         'keys' => %w{first second third},
         'continuation' => 'examplecontinuation'
       }.to_json
-      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
-      %w{first second third}.should == @coll
-      @coll.continuation.should == 'examplecontinuation'
+      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
+      expect(%w{first second third}).to eq(@coll)
+      expect(@coll.continuation).to eq('examplecontinuation')
     end
     it "should accept a list of results hashes" do
       @input = {
@@ -27,9 +27,9 @@ describe Riak::IndexCollection do
         ]
       }.to_json
 
-      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
-      %w{first second other}.should == @coll
-      {'first' => %w{first}, 'second' => %w{second other}}.should == @coll.with_terms
+      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
+      expect(%w{first second other}).to eq(@coll)
+      expect({'first' => %w{first}, 'second' => %w{second other}}).to eq(@coll.with_terms)
     end
     it "should accept a list of results hashes and a continuation" do
       @input = {
@@ -41,10 +41,10 @@ describe Riak::IndexCollection do
         'continuation' => 'examplecontinuation'
       }.to_json
 
-      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
-      %w{first second other}.should == @coll
-      @coll.continuation.should == 'examplecontinuation'
-      {'first' => %w{first}, 'second' => %w{second other}}.should == @coll.with_terms
+      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
+      expect(%w{first second other}).to eq(@coll)
+      expect(@coll.continuation).to eq('examplecontinuation')
+      expect({'first' => %w{first}, 'second' => %w{second other}}).to eq(@coll.with_terms)
     end
   end
 end

data/spec/riak/link_spec.rb

@@ -4,82 +4,82 @@ describe Riak::Link do
   describe "parsing a link header" do
     it "should create Link objects from the data" do
       result = Riak::Link.parse('</riak/foo/bar>; rel="tag", </riak/foo>; rel="up"')
-      result.should be_kind_of(Array)
-      result.should be_all {|i| Riak::Link === i }
+      expect(result).to be_kind_of(Array)
+      expect(result).to be_all {|i| Riak::Link === i }
     end
 
     it "should set the bucket, key, url and rel parameters properly" do
       result = Riak::Link.parse('</riak/foo/bar>; riaktag="tag", </riak/foo>; rel="up"')
-      result[0].url.should == "/riak/foo/bar"
-      result[0].bucket.should == "foo"
-      result[0].key.should == "bar"
-      result[0].rel.should == "tag"
-      result[1].url.should == "/riak/foo"
-      result[1].bucket.should == "foo"
-      result[1].key.should == nil
-      result[1].rel.should == "up"
+      expect(result[0].url).to eq("/riak/foo/bar")
+      expect(result[0].bucket).to eq("foo")
+      expect(result[0].key).to eq("bar")
+      expect(result[0].rel).to eq("tag")
+      expect(result[1].url).to eq("/riak/foo")
+      expect(result[1].bucket).to eq("foo")
+      expect(result[1].key).to eq(nil)
+      expect(result[1].rel).to eq("up")
     end
 
     it "should keep the url intact if it does not point to a bucket or bucket/key" do
       result = Riak::Link.parse('</mapred>; rel="riak_kv_wm_mapred"')
-      result[0].url.should == "/mapred"
-      result[0].bucket.should be_nil
-      result[0].key.should be_nil
+      expect(result[0].url).to eq("/mapred")
+      expect(result[0].bucket).to be_nil
+      expect(result[0].key).to 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'
+      expect(result.bucket).to eq('b')
+      expect(result.key).to eq('k')
+      expect(result.tag).to eq('tag')
     end
   end
 
   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"'
+      expect(Riak::Link.new("/riak/foo", "up").to_s).to eq('</riak/foo>; riaktag="up"')
+      expect(Riak::Link.new("/riak/foo/bar", "next").to_s).to eq('</riak/foo/bar>; riaktag="next"')
+      expect(Riak::Link.new("/riak", "riak_kv_wm_raw").to_s).to eq('</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"'
+      expect(Riak::Link.new("bucket", "key", "tag").to_s(true)).to eq('</buckets/bucket/keys/key>; riaktag="tag"')
+      expect(Riak::Link.parse('</riak/bucket/key>; riaktag="tag"').first.to_s(true)).to eq('</buckets/bucket/keys/key>; riaktag="tag"')
     end
   end
 
   it "should convert to a walk spec when pointing to an object" do
-    Riak::Link.new("/riak/foo/bar", "next").to_walk_spec.to_s.should == "foo,next,_"
-    lambda { Riak::Link.new("/riak/foo", "up").to_walk_spec }.should raise_error
+    expect(Riak::Link.new("/riak/foo/bar", "next").to_walk_spec.to_s).to eq("foo,next,_")
+    expect { Riak::Link.new("/riak/foo", "up").to_walk_spec }.to raise_error
   end
 
   it "should be equivalent to a link with the same url and rel" do
     one = Riak::Link.new("/riak/foo/bar", "next")
     two = Riak::Link.new("/riak/foo/bar", "next")
-    one.should == two
-    [one].should include(two)
-    [two].should include(one)
+    expect(one).to eq(two)
+    expect([one]).to include(two)
+    expect([two]).to include(one)
   end
 
   it "should unescape the bucket name" do
-    Riak::Link.new("/riak/bucket%20spaces/key", "foo").bucket.should == "bucket spaces"
+    expect(Riak::Link.new("/riak/bucket%20spaces/key", "foo").bucket).to eq("bucket spaces")
   end
 
   it "should unescape the key name" do
-    Riak::Link.new("/riak/bucket/key%2Fname", "foo").key.should == "key/name"
+    expect(Riak::Link.new("/riak/bucket/key%2Fname", "foo").key).to eq("key/name")
   end
 
   it "should not rely on the prefix to equal /riak/ when extracting the bucket and key" do
     link = Riak::Link.new("/raw/bucket/key", "foo")
-    link.bucket.should == "bucket"
-    link.key.should == "key"
+    expect(link.bucket).to eq("bucket")
+    expect(link.key).to eq("key")
   end
 
   it "should construct from bucket, key and tag" do
     link = Riak::Link.new("bucket", "key", "tag")
-    link.bucket.should == "bucket"
-    link.key.should == "key"
-    link.tag.should == "tag"
-    link.url.should == "/riak/bucket/key"
+    expect(link.bucket).to eq("bucket")
+    expect(link.key).to eq("key")
+    expect(link.tag).to eq("tag")
+    expect(link.url).to eq("/riak/bucket/key")
   end
 end

data/spec/riak/list_buckets_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Riak::ListBuckets do
   before :each do
-    @client = Riak::Client.new protocol: 'pbc'
-    @backend = mock 'backend'
-    @fake_pool = mock 'connection pool'
-    @fake_pool.stub(:take).and_yield(@backend)
+    @client = Riak::Client.new
+    @backend = double 'backend'
+    @fake_pool = double 'connection pool'
+    allow(@fake_pool).to receive(:take).and_yield(@backend)
 
-    @expect_list = @backend.should_receive(:list_buckets)
+    @expect_list = expect(@backend).to receive(:list_buckets)
 
     @client.instance_variable_set :@protobuffs_pool, @fake_pool
   end
@@ -33,9 +33,9 @@ describe Riak::ListBuckets do
       end
 
       @yielded.each do |b|
-        b.should be_a Riak::Bucket
+        expect(b).to be_a Riak::Bucket
       end
-      @yielded.map(&:name).should == %w{abc abd abe bbb ccc ddd}
+      expect(@yielded.map(&:name)).to eq(%w{abc abd abe bbb ccc ddd})
     end
   end
 end

data/spec/riak/map_reduce/filter_builder_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe Riak::MapReduce::FilterBuilder do
   subject { Riak::MapReduce::FilterBuilder.new }
   it "should evaluate the passed block on initialization" do
-    subject.class.new do
+    expect(subject.class.new do
       matches "foo"
-    end.to_a.should == [[:matches, "foo"]]
+    end.to_a).to eq([[:matches, "foo"]])
   end
 
   it "should add filters to the list" do
     subject.to_lower
     subject.similar_to("ripple", 3)
-    subject.to_a.should == [[:to_lower],[:similar_to, "ripple", 3]]
+    expect(subject.to_a).to eq([[:to_lower],[:similar_to, "ripple", 3]])
   end
 
   it "should add a logical operation with a block" do
@@ -19,14 +19,14 @@ describe Riak::MapReduce::FilterBuilder do
       starts_with "foo"
       ends_with "bar"
     end
-    subject.to_a.should == [[:or, [[:starts_with, "foo"],[:ends_with, "bar"]]]]
+    expect(subject.to_a).to eq([[:or, [[:starts_with, "foo"],[:ends_with, "bar"]]]])
   end
 
   it "should raise an error on a filter arity mismatch" do
-    lambda { subject.less_than }.should raise_error(ArgumentError)
+    expect { subject.less_than }.to raise_error(ArgumentError)
   end
 
   it "should raise an error when a block is not given to a logical operation" do
-    lambda { subject._or }.should raise_error(ArgumentError)
+    expect { subject._or }.to raise_error(ArgumentError)
   end
 end

data/spec/riak/map_reduce/phase_spec.rb

@@ -8,52 +8,52 @@ describe Riak::MapReduce::Phase do
 
   it "should initialize with a type and a function" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => @js_fun, :language => "javascript")
-    phase.type.should == :map
-    phase.function.should == @js_fun
-    phase.language.should == "javascript"
+    expect(phase.type).to eq(:map)
+    expect(phase.function).to eq(@js_fun)
+    expect(phase.language).to eq("javascript")
   end
 
   it "should initialize with a type and an MF" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"], :language => "erlang")
-    phase.type.should == :map
-    phase.function.should == ["module", "function"]
-    phase.language.should == "erlang"
+    expect(phase.type).to eq(:map)
+    expect(phase.function).to eq(["module", "function"])
+    expect(phase.language).to eq("erlang")
   end
 
   it "should initialize with a type and a bucket/key" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "funs", :key => "awesome_map"}, :language => "javascript")
-    phase.type.should == :map
-    phase.function.should == {:bucket => "funs", :key => "awesome_map"}
-    phase.language.should == "javascript"
+    expect(phase.type).to eq(:map)
+    expect(phase.function).to eq({:bucket => "funs", :key => "awesome_map"})
+    expect(phase.language).to eq("javascript")
   end
 
   it "should assume the language is erlang when the function is an array" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"])
-    phase.language.should == "erlang"
+    expect(phase.language).to eq("erlang")
   end
 
   it "should assume the language is javascript when the function is a string and starts with function" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => @js_fun)
-    phase.language.should == "javascript"
+    expect(phase.language).to eq("javascript")
   end
 
   it "should assume the language is erlang when the function is a string and starts with anon fun" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => @erl_fun)
-    phase.language.should == "erlang"
+    expect(phase.language).to eq("erlang")
   end
 
   it "should assume the language is javascript when the function is a hash" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "jobs", :key => "awesome_map"})
-    phase.language.should == "javascript"
+    expect(phase.language).to eq("javascript")
   end
 
   it "should accept a WalkSpec for the function when a link phase" do
     phase = Riak::MapReduce::Phase.new(:type => :link, :function => Riak::WalkSpec.new({}))
-    phase.function.should be_kind_of(Riak::WalkSpec)
+    expect(phase.function).to be_kind_of(Riak::WalkSpec)
   end
 
   it "should raise an error if a WalkSpec is given for a phase type other than :link" do
-    lambda { Riak::MapReduce::Phase.new(:type => :map, :function => Riak::WalkSpec.new({})) }.should raise_error(ArgumentError)
+    expect { Riak::MapReduce::Phase.new(:type => :map, :function => Riak::WalkSpec.new({})) }.to raise_error(ArgumentError)
   end
 
   describe "converting to JSON for the job" do
@@ -68,41 +68,41 @@ describe Riak::MapReduce::Phase do
         end
 
         it "should be an object with a single key of '#{type}'" do
-          @phase.to_json.should =~ /^\{"#{type}":/
+          expect(@phase.to_json).to match(/^\{"#{type}":/)
         end
 
         it "should include the language" do
-          @phase.to_json.should =~ /"language":/
+          expect(@phase.to_json).to match(/"language":/)
         end
 
         it "should include the keep value" do
-          @phase.to_json.should =~ /"keep":false/
+          expect(@phase.to_json).to match(/"keep":false/)
           @phase.keep = true
-          @phase.to_json.should =~ /"keep":true/
+          expect(@phase.to_json).to match(/"keep":true/)
         end
 
         it "should include the function source when the function is a source string" do
           @phase.function = "function(v,_,_){ return v; }"
-          @phase.to_json.should include(@phase.function)
-          @phase.to_json.should =~ /"source":/
+          expect(@phase.to_json).to include(@phase.function)
+          expect(@phase.to_json).to match(/"source":/)
         end
 
         it "should include the function name when the function is not a lambda" do
           @phase.function = "Riak.mapValues"
-          @phase.to_json.should include('"name":"Riak.mapValues"')
-          @phase.to_json.should_not include('"source"')
+          expect(@phase.to_json).to include('"name":"Riak.mapValues"')
+          expect(@phase.to_json).not_to include('"source"')
         end
 
         it "should include the bucket and key when referring to a stored function" do
           @phase.function = {:bucket => "design", :key => "wordcount_map"}
-          @phase.to_json.should include('"bucket":"design"')
-          @phase.to_json.should include('"key":"wordcount_map"')
+          expect(@phase.to_json).to include('"bucket":"design"')
+          expect(@phase.to_json).to include('"key":"wordcount_map"')
         end
 
         it "should include the module and function when invoking an Erlang function" do
           @phase.function = ["riak_mapreduce", "mapreduce_fun"]
-          @phase.to_json.should include('"module":"riak_mapreduce"')
-          @phase.to_json.should include('"function":"mapreduce_fun"')
+          expect(@phase.to_json).to include('"module":"riak_mapreduce"')
+          expect(@phase.to_json).to include('"function":"mapreduce_fun"')
         end
       end
     end
@@ -114,28 +114,28 @@ describe Riak::MapReduce::Phase do
       end
 
       it "should be an object of a single key 'link'" do
-        @phase.to_json.should =~ /^\{"link":/
+        expect(@phase.to_json).to match(/^\{"link":/)
       end
 
       it "should include the bucket" do
-        @phase.to_json.should =~ /"bucket":"_"/
+        expect(@phase.to_json).to match(/"bucket":"_"/)
         @phase.function[:bucket] = "foo"
-        @phase.to_json.should =~ /"bucket":"foo"/
+        expect(@phase.to_json).to match(/"bucket":"foo"/)
       end
 
       it "should include the tag" do
-        @phase.to_json.should =~ /"tag":"_"/
+        expect(@phase.to_json).to match(/"tag":"_"/)
         @phase.function[:tag] = "parent"
-        @phase.to_json.should =~ /"tag":"parent"/
+        expect(@phase.to_json).to match(/"tag":"parent"/)
       end
 
       it "should include the keep value" do
-        @phase.to_json.should =~ /"keep":false/
+        expect(@phase.to_json).to match(/"keep":false/)
         @phase.keep = true
-        @phase.to_json.should =~ /"keep":true/
+        expect(@phase.to_json).to match(/"keep":true/)
         @phase.keep = false
         @phase.function[:keep] = true
-        @phase.to_json.should =~ /"keep":true/
+        expect(@phase.to_json).to match(/"keep":true/)
       end
     end
   end

data/spec/riak/map_reduce_spec.rb

@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Riak::MapReduce do
   before :each do
     @client = Riak::Client.new
-    @backend = mock("Backend")
-    @client.stub!(:backend).and_yield(@backend)
+    @backend = double("Backend")
+    allow(@client).to receive(:backend).and_yield(@backend)
     @mr = Riak::MapReduce.new(@client)
   end
 
   it "should require a client" do
-    lambda { Riak::MapReduce.new }.should raise_error
-    lambda { Riak::MapReduce.new(@client) }.should_not raise_error
+    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
-    @mr.inputs.should == []
-    @mr.query.should == []
+    expect(@mr.inputs).to eq([])
+    expect(@mr.query).to eq([])
   end
 
   it "should yield itself when given a block on initializing" do
@@ -23,46 +23,46 @@ describe Riak::MapReduce do
     @mr = Riak::MapReduce.new(@client) do |mr|
       @mr2 = mr
     end
-    @mr2.should == @mr
+    expect(@mr2).to eq(@mr)
   end
 
   describe "adding inputs" do
     it "should return self for chaining" do
-      @mr.add("foo", "bar").should == @mr
+      expect(@mr.add("foo", "bar")).to eq(@mr)
     end
 
     it "should add bucket/key pairs to the inputs" do
       @mr.add("foo","bar")
-      @mr.inputs.should == [["foo","bar"]]
+      expect(@mr.inputs).to eq([["foo","bar"]])
     end
 
     it "should add an array containing a bucket/key pair to the inputs" do
       @mr.add(["foo","bar"])
-      @mr.inputs.should == [["foo","bar"]]
+      expect(@mr.inputs).to eq([["foo","bar"]])
     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")
       @mr.add(obj)
-      @mr.inputs.should == [["foo", "bar"]]
+      expect(@mr.inputs).to eq([["foo", "bar"]])
     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]]
+      expect(@mr.inputs).to eq([["foo","bar",1000]])
     end
 
     it "should use a bucket name as the single input" do
       @mr.add(Riak::Bucket.new(@client, "foo"))
-      @mr.inputs.should == "foo"
+      expect(@mr.inputs).to eq("foo")
       @mr.add("docs")
-      @mr.inputs.should == "docs"
+      expect(@mr.inputs).to eq("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]]}
+      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
@@ -71,18 +71,18 @@ describe Riak::MapReduce do
         string_to_int
         between 2009, 2010
       end
-      @mr.inputs.should == {:bucket => "foo", :key_filters => [[: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
 
     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"}
+        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
-        @mr.index("foo", "rank_int", 10..20).should == @mr
-        @mr.inputs.should == {:bucket => "foo", :index => "rank_int", :start => 10, :end => 20}
+        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
@@ -101,31 +101,31 @@ describe Riak::MapReduce do
 
         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"]]
+          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
           @mr.add(["[foo]","(bar)"])
-          @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+          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
           bucket = Riak::Bucket.new(@client, "[foo]")
           obj = Riak::RObject.new(bucket, "(bar)")
           @mr.add(obj)
-          @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29"]]
+          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
           @mr.add(["[foo]","(bar)","[]()"])
-          @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29","[]()"]]
+          expect(@mr.inputs).to eq([["%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"
+          expect(@mr.inputs).to eq("%5Bfoo%5D")
           @mr.add("docs")
-          @mr.inputs.should == "docs"
+          expect(@mr.inputs).to eq("docs")
         end
       end
 
@@ -135,31 +135,31 @@ describe Riak::MapReduce do
 
         it "should add bucket/key pairs to the inputs with bucket and key unescaped" do
           @mr.add("[foo]","(bar)")
-          @mr.inputs.should == [["[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
           @mr.add(["[foo]","(bar)"])
-          @mr.inputs.should == [["[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
           bucket = Riak::Bucket.new(@client, "[foo]")
           obj = Riak::RObject.new(bucket, "(bar)")
           @mr.add(obj)
-          @mr.inputs.should == [["[foo]","(bar)"]]
+          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
           @mr.add(["[foo]","(bar)","[]()"])
-          @mr.inputs.should == [["[foo]","(bar)","[]()"]]
+          expect(@mr.inputs).to eq([["[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]"
+          expect(@mr.inputs).to eq("[foo]")
           @mr.add("docs")
-          @mr.inputs.should == "docs"
+          expect(@mr.inputs).to eq("docs")
         end
       end
     end
@@ -170,31 +170,31 @@ describe Riak::MapReduce do
 
       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"]]
+        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
         @mr.add(["[foo]","(bar)"])
-        @mr.inputs.should == [["%5Bfoo%5D","%28bar%29"]]
+        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
         bucket = Riak::Bucket.new(@client, "[foo]")
         obj = Riak::RObject.new(bucket, "(bar)")
         @mr.add(obj)
-        @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29"]]
+        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
         @mr.add(["[foo]","(bar)","[]()"])
-        @mr.inputs.should == [["%5Bfoo%5D", "%28bar%29","[]()"]]
+        expect(@mr.inputs).to eq([["%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"
+        expect(@mr.inputs).to eq("%5Bfoo%5D")
         @mr.add("docs")
-        @mr.inputs.should == "docs"
+        expect(@mr.inputs).to eq("docs")
       end
     end
 
@@ -203,13 +203,13 @@ describe Riak::MapReduce do
       after { Riak.disable_list_keys_warnings = true }
 
       it "should warn about list-keys on buckets" do
-        @mr.should_receive(:warn).twice
+        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
-        @mr.should_receive(:warn)
+        expect(@mr).to receive(:warn)
         @mr.filter("foo") { matches "bar" }
       end
     end
@@ -218,111 +218,111 @@ describe Riak::MapReduce do
   [:map, :reduce].each do |type|
     describe "adding #{type} phases" do
       it "should return self for chaining" do
-        @mr.send(type, "function(){}").should == @mr
+        expect(@mr.send(type, "function(){}")).to eq(@mr)
       end
 
       it "should accept a function string" do
         @mr.send(type, "function(){}")
-        @mr.query.should have(1).items
+        expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
-        phase.function.should == "function(){}"
-        phase.type.should == type
+        expect(phase.function).to eq("function(){}")
+        expect(phase.type).to eq(type)
       end
 
       it "should accept a function and options" do
         @mr.send(type, "function(){}", :keep => true)
-        @mr.query.should have(1).items
+        expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
-        phase.function.should == "function(){}"
-        phase.type.should == type
-        phase.keep.should be_true
+        expect(phase.function).to eq("function(){}")
+        expect(phase.type).to eq(type)
+        expect(phase.keep).to be_truthy
       end
 
       it "should accept a module/function pair" do
         @mr.send(type, ["riak","mapsomething"])
-        @mr.query.should have(1).items
+        expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
-        phase.function.should == ["riak", "mapsomething"]
-        phase.type.should == type
-        phase.language.should == "erlang"
+        expect(phase.function).to eq(["riak", "mapsomething"])
+        expect(phase.type).to eq(type)
+        expect(phase.language).to eq("erlang")
       end
 
       it "should accept a module/function pair with extra options" do
         @mr.send(type, ["riak", "mapsomething"], :arg => [1000])
-        @mr.query.should have(1).items
+        expect(@mr.query.size).to eq(1)
         phase = @mr.query.first
-        phase.function.should == ["riak", "mapsomething"]
-        phase.type.should == type
-        phase.language.should == "erlang"
-        phase.arg.should == [1000]
+        expect(phase.function).to eq(["riak", "mapsomething"])
+        expect(phase.type).to eq(type)
+        expect(phase.language).to eq("erlang")
+        expect(phase.arg).to eq([1000])
       end
     end
   end
 
   describe "adding link phases" do
     it "should return self for chaining" do
-      @mr.link({}).should == @mr
+      expect(@mr.link({})).to eq(@mr)
     end
 
     it "should accept a WalkSpec" do
       @mr.link(Riak::WalkSpec.new(:tag => "next"))
-      @mr.query.should have(1).items
+      expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
-      phase.type.should == :link
-      phase.function.should be_kind_of(Riak::WalkSpec)
-      phase.function.tag.should == "next"
+      expect(phase.type).to eq(:link)
+      expect(phase.function).to be_kind_of(Riak::WalkSpec)
+      expect(phase.function.tag).to eq("next")
     end
 
     it "should accept a WalkSpec and a hash of options" do
       @mr.link(Riak::WalkSpec.new(:bucket => "foo"), :keep => true)
-      @mr.query.should have(1).items
+      expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
-      phase.type.should == :link
-      phase.function.should be_kind_of(Riak::WalkSpec)
-      phase.function.bucket.should == "foo"
-      phase.keep.should be_true
+      expect(phase.type).to eq(:link)
+      expect(phase.function).to be_kind_of(Riak::WalkSpec)
+      expect(phase.function.bucket).to eq("foo")
+      expect(phase.keep).to be_truthy
     end
 
     it "should accept a hash of options intermingled with the walk spec options" do
       @mr.link(:tag => "snakes", :arg => [1000])
-      @mr.query.should have(1).items
+      expect(@mr.query.size).to eq(1)
       phase = @mr.query.first
-      phase.arg.should == [1000]
-      phase.function.should be_kind_of(Riak::WalkSpec)
-      phase.function.tag.should == "snakes"
+      expect(phase.arg).to eq([1000])
+      expect(phase.function).to be_kind_of(Riak::WalkSpec)
+      expect(phase.function.tag).to eq("snakes")
     end
   end
 
   describe "converting to JSON for the job" do
     it "should include the inputs and query keys" do
-      @mr.to_json.should =~ /"inputs":/
+      expect(@mr.to_json).to match(/"inputs":/)
     end
 
     it "should map phases to their JSON equivalents" do
       phase = Riak::MapReduce::Phase.new(:type => :map, :function => "function(){}")
       @mr.query << phase
-      @mr.to_json.should include('"source":"function(){}"')
-      @mr.to_json.should include('"query":[{"map":{')
+      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
       @mr.add("foo")
-      @mr.to_json.should include('"inputs":"foo"')
+      expect(@mr.to_json).to include('"inputs":"foo"')
     end
 
     it "should emit an array of inputs when there are multiple inputs" do
       @mr.add("foo","bar",1000).add("foo","baz")
-      @mr.to_json.should include('"inputs":[["foo","bar",1000],["foo","baz"]]')
+      expect(@mr.to_json).to include('"inputs":[["foo","bar",1000],["foo","baz"]]')
     end
 
     it "should add the timeout value when set" do
       @mr.timeout(50000)
-      @mr.to_json.should include('"timeout":50000')
+      expect(@mr.to_json).to include('"timeout":50000')
     end
   end
 
   it "should return self from setting the timeout" do
-    @mr.timeout(5000).should == @mr
+    expect(@mr.timeout(5000)).to eq(@mr)
   end
 
   describe "executing the map reduce job" do
@@ -331,32 +331,34 @@ describe Riak::MapReduce do
     end
 
     it "should submit the query to the backend" do
-      @backend.should_receive(:mapred).with(@mr).and_return([])
-      @mr.run.should == []
+      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
       arr = []
-      @backend.should_receive(:mapred).with(@mr).and_yield("foo").and_yield("bar")
+      expect(@backend).to receive(:mapred).with(@mr).and_yield("foo").and_yield("bar")
       @mr.run {|v| arr << v }
-      arr.should == ["foo", "bar"]
+      expect(arr).to eq(["foo", "bar"])
     end
 
     it "should interpret failed requests with JSON content-types as map reduce errors" do
-      @backend.stub!(:mapred).and_raise(Riak::HTTPFailedRequest.new(:post, 200, 500, {"content-type" => ["application/json"]}, '{"error":"syntax error"}'))
-      lambda { @mr.run }.should raise_error(Riak::MapReduceError)
+      allow(@backend).to receive(:mapred).
+        and_raise(Riak::ProtobuffsFailedRequest.new(:server_error, '{"error":"syntax error"}'))
+      expect{ @mr.run }.to raise_error(Riak::MapReduceError)
       begin
         @mr.run
       rescue Riak::MapReduceError => mre
-        mre.message.should include('{"error":"syntax error"}')
+        expect(mre.message).to include('{"error":"syntax error"}')
       else
         fail "No exception raised!"
       end
     end
 
     it "should re-raise non-JSON error responses" do
-      @backend.stub!(:mapred).and_raise(Riak::HTTPFailedRequest.new(:post, 200, 500, {"content-type" => ["text/plain"]}, 'Oops, you bwoke it.'))
-      lambda { @mr.run }.should raise_error(Riak::FailedRequest)
+      allow(@backend).to receive(:mapred).
+        and_raise(Riak::ProtobuffsFailedRequest.new(:server_error, 'Oops, you bwoke it.'))
+      expect { @mr.run }.to raise_error(Riak::FailedRequest)
     end
   end
 end