riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/bucket_spec.rb

@@ -3,124 +3,124 @@ require 'spec_helper'
 describe Riak::Bucket do
   before :each do
     @client = Riak::Client.new
-    @backend = mock("Backend")
-    @client.stub!(:backend).and_yield(@backend)
-    @client.stub!(:http).and_yield(@backend)
+    @backend = double("Backend")
+    allow(@client).to receive(:backend).and_yield(@backend)
+    allow(@client).to receive(:http).and_yield(@backend)
     @bucket = Riak::Bucket.new(@client, "foo")
   end
 
   describe "when initializing" do
     it "should require a client and a name" do
-      lambda { Riak::Bucket.new }.should raise_error
-      lambda { Riak::Bucket.new(@client) }.should raise_error
-      lambda { Riak::Bucket.new("foo") }.should raise_error
-      lambda { Riak::Bucket.new("foo", @client) }.should raise_error
-      lambda { Riak::Bucket.new(@client, "foo") }.should_not raise_error
+      expect { Riak::Bucket.new }.to raise_error
+      expect { Riak::Bucket.new(@client) }.to raise_error
+      expect { Riak::Bucket.new("foo") }.to raise_error
+      expect { Riak::Bucket.new("foo", @client) }.to raise_error
+      expect { Riak::Bucket.new(@client, "foo") }.not_to raise_error
       expect { Riak::Bucket.new(@client, '') }.to raise_error(ArgumentError)
     end
 
     it "should set the client and name attributes" do
       bucket = Riak::Bucket.new(@client, "foo")
-      bucket.client.should == @client
-      bucket.name.should == "foo"
+      expect(bucket.client).to eq(@client)
+      expect(bucket.name).to eq("foo")
     end
   end
 
   describe "accessing keys" do
     it "should list the keys" do
-      @backend.should_receive(:list_keys).with(@bucket, {}).and_return(["bar"])
-      @bucket.keys.should == ["bar"]
+      expect(@backend).to receive(:list_keys).with(@bucket, {}).and_return(["bar"])
+      expect(@bucket.keys).to eq(["bar"])
     end
 
     it "should allow streaming keys through block" do
-      @backend.should_receive(:list_keys).with(@bucket, {}).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
+      expect(@backend).to receive(:list_keys).with(@bucket, {}).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
       all_keys = []
       @bucket.keys do |list|
         all_keys.concat(list)
       end
-      all_keys.should == ["bar", "baz"]
+      expect(all_keys).to eq(["bar", "baz"])
     end
 
     it "should not cache the list of keys" do
-      @backend.should_receive(:list_keys).with(@bucket, {}).twice.and_return(["bar"])
-      2.times { @bucket.keys.should == ['bar'] }
+      expect(@backend).to receive(:list_keys).with(@bucket, {}).twice.and_return(["bar"])
+      2.times { expect(@bucket.keys).to eq(['bar']) }
     end
 
     it "should warn about the expense of list-keys when warnings are not disabled" do
       Riak.disable_list_keys_warnings = false
-      @backend.stub!(:list_keys).and_return(%w{test test2})
-      @bucket.should_receive(:warn)
+      allow(@backend).to receive(:list_keys).and_return(%w{test test2})
+      expect(@bucket).to receive(:warn)
       @bucket.keys
       Riak.disable_list_keys_warnings = true
     end
 
     it "should allow a specified timeout when listing keys" do
-      @backend.should_receive(:list_keys).with(@bucket, timeout: 1234).and_return(%w{bar})
+      expect(@backend).to receive(:list_keys).with(@bucket, timeout: 1234).and_return(%w{bar})
 
       keys = @bucket.keys timeout: 1234
 
-      keys.should == %w{bar}
+      expect(keys).to eq(%w{bar})
     end
   end
 
   describe "accessing a counter" do
     it "should return a counter object" do
-      Riak::Counter.should_receive(:new).with(@bucket, 'asdf').and_return('example counter')
+      expect(Riak::Counter).to receive(:new).with(@bucket, 'asdf').and_return('example counter')
       
       new_counter = @bucket.counter 'asdf'
 
-      new_counter.should == 'example counter'
+      expect(new_counter).to eq('example counter')
     end
   end
 
   describe "setting the bucket properties" do
     it "should prefetch the properties when they are not present" do
-      @backend.stub!(:set_bucket_props)
-      @backend.should_receive(:get_bucket_props).with(@bucket).and_return({"name" => "foo"})
+      allow(@backend).to receive(:set_bucket_props)
+      expect(@backend).to receive(:get_bucket_props).with(@bucket, {  }).and_return({"name" => "foo"})
       @bucket.props = {"precommit" => []}
     end
 
     it "should set the new properties on the bucket" do
       @bucket.instance_variable_set(:@props, {}) # Pretend they are there
-      @backend.should_receive(:set_bucket_props).with(@bucket, { :name => "foo" })
+      expect(@backend).to receive(:set_bucket_props).with(@bucket, { :name => "foo" }, nil)
       @bucket.props = { :name => "foo" }
     end
 
     it "should raise an error if an invalid type is given" do
-      lambda { @bucket.props = "blah" }.should raise_error(ArgumentError)
+      expect { @bucket.props = "blah" }.to raise_error(ArgumentError)
     end
   end
 
   describe "fetching the bucket properties" do
     it "should fetch properties on first access" do
-      @bucket.instance_variable_get(:@props).should be_nil
-      @backend.should_receive(:get_bucket_props).with(@bucket).and_return({"name" => "foo"})
-      @bucket.props.should == {"name" => "foo"}
+      expect(@bucket.instance_variable_get(:@props)).to be_nil
+      expect(@backend).to receive(:get_bucket_props).with(@bucket, {  }).and_return({"name" => "foo"})
+      expect(@bucket.props).to eq({"name" => "foo"})
     end
 
     it "should memoize fetched properties" do
-      @backend.should_receive(:get_bucket_props).once.with(@bucket).and_return({"name" => "foo"})
-      @bucket.props.should == {"name" => "foo"}
-      @bucket.props.should == {"name" => "foo"}
+      expect(@backend).to receive(:get_bucket_props).once.with(@bucket, {  }).and_return({"name" => "foo"})
+      expect(@bucket.props).to eq({"name" => "foo"})
+      expect(@bucket.props).to eq({"name" => "foo"})
     end
   end
 
   describe "clearing the bucket properties" do
     it "should make the request and delete the internal properties cache" do
-      @client.should_receive(:clear_bucket_props).with(@bucket).and_return(true)
-      @bucket.clear_props.should be_true
-      @bucket.instance_variable_get(:@props).should be_nil
+      expect(@client).to receive(:clear_bucket_props).with(@bucket).and_return(true)
+      expect(@bucket.clear_props).to be_truthy
+      expect(@bucket.instance_variable_get(:@props)).to be_nil
     end
   end
 
   describe "fetching an object" do
     it "should fetch the object via the backend" do
-      @backend.should_receive(:fetch_object).with(@bucket, "db", {}).and_return(nil)
+      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {}).and_return(nil)
       @bucket.get("db")
     end
 
     it "should use the specified R quroum" do
-      @backend.should_receive(:fetch_object).with(@bucket, "db", {:r => 2}).and_return(nil)
+      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {:r => 2}).and_return(nil)
       @bucket.get("db", :r => 2)
     end
 
@@ -134,56 +134,59 @@ describe Riak::Bucket do
   describe "creating a new blank object" do
     it "should instantiate the object with the given key, default to JSON" do
       obj = @bucket.new('bar')
-      obj.should be_kind_of(Riak::RObject)
-      obj.key.should == 'bar'
-      obj.content_type.should == 'application/json'
+      expect(obj).to be_kind_of(Riak::RObject)
+      expect(obj.key).to eq('bar')
+      expect(obj.content_type).to eq('application/json')
     end
   end
 
   describe "fetching or creating a new object" do
+    let(:not_found_error){ Riak::ProtobuffsFailedRequest.new :not_found, 'not found' }
+    let(:other_error){ Riak::ProtobuffsFailedRequest.new :server_error, 'server error' }
+
     it "should return the existing object if present" do
-      @object = mock("RObject")
-      @backend.should_receive(:fetch_object).with(@bucket,"db", {}).and_return(@object)
-      @bucket.get_or_new('db').should == @object
+      @object = double("RObject")
+      expect(@backend).to receive(:fetch_object).with(@bucket,"db", {}).and_return(@object)
+      expect(@bucket.get_or_new('db')).to eq(@object)
     end
 
     it "should create a new blank object if the key does not exist" do
-      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "File not found"))
+      expect(@backend).to receive(:fetch_object).and_raise(not_found_error)
       obj = @bucket.get_or_new('db')
-      obj.key.should == 'db'
-      obj.data.should be_blank
+      expect(obj.key).to eq('db')
+      expect(obj.data).to be_blank
     end
 
     it "should bubble up non-ok non-missing errors" do
-      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 500, {}, "File not found"))
-      lambda { @bucket.get_or_new('db') }.should raise_error(Riak::HTTPFailedRequest)
+      expect(@backend).to receive(:fetch_object).and_raise(other_error)
+      expect { @bucket.get_or_new('db') }.to raise_error(Riak::ProtobuffsFailedRequest)
     end
 
     it "should pass along the given R quorum parameter" do
-      @object = mock("RObject")
-      @backend.should_receive(:fetch_object).with(@bucket,"db", {:r => "all"}).and_return(@object)
-      @bucket.get_or_new('db', :r => "all").should == @object
+      @object = double("RObject")
+      expect(@backend).to receive(:fetch_object).with(@bucket,"db", {:r => "all"}).and_return(@object)
+      expect(@bucket.get_or_new('db', :r => "all")).to eq(@object)
     end
   end
 
   describe "fetching multiple objects" do
     it 'should get each object individually' do
-      @object1 = mock('obj1')
-      @object2 = mock('obj2')
-      @bucket.should_receive(:[]).with('key1').and_return(@object1)
-      @bucket.should_receive(:[]).with('key2').and_return(@object2)
+      @object1 = double('obj1')
+      @object2 = double('obj2')
+      expect(@bucket).to receive(:[]).with('key1').and_return(@object1)
+      expect(@bucket).to receive(:[]).with('key2').and_return(@object2)
 
       @results = @bucket.get_many %w{key1 key2}
 
-      @results['key1'].should == @object1
-      @results['key2'].should == @object2
+      expect(@results['key1']).to eq(@object1)
+      expect(@results['key2']).to eq(@object2)
     end
   end
 
   describe "querying an index" do
     it "should list the matching keys" do
-      @backend.
-        should_receive(:get_index).
+      expect(@backend).
+        to receive(:get_index).
         with(@bucket, "test_bin", "testing", {return_terms: true}).
         and_return(Riak::IndexCollection.new_from_json({
                      'results' => [
@@ -192,38 +195,38 @@ describe Riak::Bucket do
                    }.to_json))
       result = @bucket.get_index("test_bin", "testing", return_terms: true)
 
-      result.should be_a Riak::IndexCollection
-      result.to_a.should == %w{asdf hjkl}
-      result.with_terms.should == {'testing' => %w{asdf hjkl}}
+      expect(result).to be_a Riak::IndexCollection
+      expect(result.to_a).to eq(%w{asdf hjkl})
+      expect(result.with_terms).to eq({'testing' => %w{asdf hjkl}})
     end
   end
 
   describe "get/set allow_mult property" do
     before :each do
-      @backend.stub!(:get_bucket_props).and_return({"allow_mult" => false})
+      allow(@backend).to receive(:get_bucket_props).and_return({"allow_mult" => false})
     end
 
     it "should extract the allow_mult property" do
-      @bucket.allow_mult.should be_false
+      expect(@bucket.allow_mult).to be_falsey
     end
 
     it "should set the allow_mult property" do
-      @bucket.should_receive(:props=).with(hash_including('allow_mult' => true))
+      expect(@bucket).to receive(:props=).with(hash_including('allow_mult' => true))
       @bucket.allow_mult = true
     end
   end
 
   describe "get/set the N value" do
     before :each do
-      @backend.stub!(:get_bucket_props).and_return({"n_val" => 3})
+      allow(@backend).to receive(:get_bucket_props).and_return({"n_val" => 3})
     end
 
     it "should extract the N value" do
-      @bucket.n_value.should == 3
+      expect(@bucket.n_value).to eq(3)
     end
 
     it "should set the N value" do
-      @bucket.should_receive(:props=).with(hash_including('n_val' => 1))
+      expect(@bucket).to receive(:props=).with(hash_including('n_val' => 1))
       @bucket.n_value = 1
     end
   end
@@ -231,15 +234,15 @@ describe Riak::Bucket do
   [:r, :w, :dw, :rw].each do |q|
     describe "get/set the default #{q} quorum" do
       before :each do
-        @backend.stub!(:get_bucket_props).and_return({"r" => "quorum", "w" => "quorum", "dw" => "quorum", "rw" => "quorum"})
+        allow(@backend).to receive(:get_bucket_props).and_return({"r" => "quorum", "w" => "quorum", "dw" => "quorum", "rw" => "quorum"})
       end
 
       it "should extract the default #{q} quorum" do
-        @bucket.send(q).should == "quorum"
+        expect(@bucket.send(q)).to eq("quorum")
       end
 
       it "should set the #{q} quorum" do
-        @bucket.should_receive(:props=).with(hash_including("#{q}" => 1))
+        expect(@bucket).to receive(:props=).with(hash_including("#{q}" => 1))
         @bucket.send("#{q}=",1)
       end
     end
@@ -247,24 +250,25 @@ describe Riak::Bucket do
 
   describe "checking whether a key exists" do
     it "should return true if the object does exist" do
-      @backend.should_receive(:fetch_object).and_return(mock)
-      @bucket.exists?("foo").should be_true
+      expect(@backend).to receive(:fetch_object).and_return(double)
+      expect(@bucket.exists?("foo")).to be_truthy
     end
 
     it "should return false if the object doesn't exist" do
-      @backend.should_receive(:fetch_object).and_raise(Riak::HTTPFailedRequest.new(:get, [200,300], 404, {}, "not found"))
-      @bucket.exists?("foo").should be_false
+      expect(@backend).to receive(:fetch_object).
+        and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, "not found"))
+      expect(@bucket.exists?("foo")).to be_falsey
     end
   end
 
   describe "deleting an object" do
     it "should delete a key from within the bucket" do
-      @backend.should_receive(:delete_object).with(@bucket, "bar", {})
+      expect(@backend).to receive(:delete_object).with(@bucket, "bar", {})
       @bucket.delete('bar')
     end
 
     it "should use the specified RW quorum" do
-      @backend.should_receive(:delete_object).with(@bucket, "bar", {:rw => "all"})
+      expect(@backend).to receive(:delete_object).with(@bucket, "bar", {:rw => "all"})
       @bucket.delete('bar', :rw => "all")
     end
   end

data/spec/riak/client_spec.rb

@@ -1,81 +1,37 @@
 require 'spec_helper'
 
-describe Riak::Client do
+describe Riak::Client, test_client: true do
   describe "when initializing" do
     it "should default a single local node" do
       client = Riak::Client.new
-      client.nodes.should == [Riak::Client::Node.new(client)]
-    end
-
-    it "should accept a protocol" do
-      client = Riak::Client.new :protocol => 'https'
-      client.protocol.should eq('https')
+      expect(client.nodes).to eq([Riak::Client::Node.new(client)])
     end
 
     it "should accept a host" do
       client = Riak::Client.new :host => "riak.basho.com"
-      client.nodes.size.should == 1
-      client.nodes.first.host.should == "riak.basho.com"
-    end
-
-    it "should accept an HTTP port" do
-      client = Riak::Client.new :http_port => 9000
-      client.nodes.size.should == 1
-      client.nodes.first.http_port.should == 9000
+      expect(client.nodes.size).to eq(1)
+      expect(client.nodes.first.host).to eq("riak.basho.com")
     end
 
     it "should accept a Protobuffs port" do
       client = Riak::Client.new :pb_port => 9000
-      client.nodes.size.should == 1
-      client.nodes.first.pb_port.should == 9000
-    end
-
-    it "should warn on setting :port" do
-      # TODO: make a deprecation utility class/module instead
-      client = Riak::Client.allocate
-      client.should_receive(:warn).and_return(true)
-      client.send :initialize, :port => 9000
-    end
-
-    it "should accept basic_auth" do
-      client = Riak::Client.new :basic_auth => "user:pass"
-      client.nodes.size.should == 1
-      client.nodes.first.basic_auth.should eq("user:pass")
+      expect(client.nodes.size).to eq(1)
+      expect(client.nodes.first.pb_port).to eq(9000)
     end
 
     it "should accept a client ID" do
       client = Riak::Client.new :client_id => "AAAAAA=="
-      client.client_id.should == "AAAAAA=="
+      expect(client.client_id).to eq("AAAAAA==")
     end
 
     it "should create a client ID if not specified" do
-      Riak::Client.new.client_id.should_not be_nil
-    end
-
-    it "should accept a path prefix" do
-      client = Riak::Client.new(:prefix => "/jiak/")
-      client.nodes.first.http_paths[:prefix].should == "/jiak/"
-    end
-
-    it "should accept a mapreduce path" do
-      client = Riak::Client.new(:mapred => "/mr")
-      client.nodes.first.http_paths[:mapred].should == "/mr"
-    end
-
-    it "should accept a luwak path" do
-      client = Riak::Client.new(:luwak => "/beans")
-      client.nodes.first.http_paths[:luwak].should == "/beans"
-    end
-
-    it "should accept a solr path" do
-      client = Riak::Client.new(:solr => "/solar")
-      client.nodes.first.http_paths[:solr].should == "/solar"
+      expect(Riak::Client.new(pb_port: test_client.nodes.first.pb_port).client_id).not_to be_nil
     end
   end
 
   it "should expose a Stamp object" do
-    subject.should respond_to(:stamp)
-    subject.stamp.should be_kind_of(Riak::Stamp)
+    expect(subject).to respond_to(:stamp)
+    expect(subject.stamp).to be_kind_of(Riak::Stamp)
   end
 
   describe "reconfiguring" do
@@ -83,94 +39,42 @@ describe Riak::Client do
       @client = Riak::Client.new
     end
 
-    describe "setting the protocol" do
-      it "should allow setting the protocol" do
-        @client.should respond_to(:protocol=)
-        @client.protocol = "https"
-        @client.protocol.should eq("https")
-      end
-
-      it "should require a valid protocol to be set" do
-        lambda { @client.protocol = 'invalid-protocol' }.should(
-                                                           raise_error(ArgumentError, /^'invalid-protocol' is not a valid protocol/))
-      end
-    end
-
-    describe "setting http auth" do
-      it "should allow setting basic_auth" do
-        @client.should respond_to(:basic_auth=)
-        @client.basic_auth = "user:pass"
-        @client.nodes.each do |node|
-          node.basic_auth.should eq("user:pass")
-        end
-      end
-    end
-
     describe "setting the client id" do
       it "should accept a string unmodified" do
         @client.client_id = "foo"
-        @client.client_id.should == "foo"
+        expect(@client.client_id).to eq("foo")
       end
 
       it "should reject an integer equal to the maximum client id" do
-        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID }.should raise_error(ArgumentError)
+        expect { @client.client_id = Riak::Client::MAX_CLIENT_ID }.to raise_error(ArgumentError)
       end
 
       it "should reject an integer larger than the maximum client id" do
-        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID + 1 }.should raise_error(ArgumentError)
+        expect { @client.client_id = Riak::Client::MAX_CLIENT_ID + 1 }.to raise_error(ArgumentError)
       end
     end
   end
 
-  describe "choosing an HTTP backend" do
-    before :each do
-      @client = Riak::Client.new
-    end
-
-    it "should choose the selected backend" do
-      @client.http_backend = :NetHTTP
-      @client.http do |h|
-        h.should be_instance_of(Riak::Client::NetHTTPBackend)
-      end
-
-      @client = Riak::Client.new
-      @client.http_backend = :Excon
-      @client.http do |h|
-        h.should be_instance_of(Riak::Client::ExconBackend)
-      end
-    end
-
-    it "should clear the existing HTTP connections when changed" do
-      @client.http_pool.should_receive(:clear)
-      @client.http_backend = :Excon
-    end
-
-    it "should raise an error when the chosen backend is not valid" do
-      Riak::Client::NetHTTPBackend.should_receive(:configured?).and_return(false)
-      lambda { @client.http { |x| } }.should raise_error
-    end
-  end
-
   describe "choosing a Protobuffs backend" do
     before :each do
-      @client = Riak::Client.new(:protocol => "pbc")
+      @client = Riak::Client.new
     end
 
     it "should choose the selected backend" do
       @client.protobuffs_backend = :Beefcake
       @client.protobuffs do |p|
-        p.should be_instance_of(Riak::Client::BeefcakeProtobuffsBackend)
+        expect(p).to be_instance_of(Riak::Client::BeefcakeProtobuffsBackend)
       end
     end
 
     it "should teardown the existing Protobuffs connections when changed" do
-      @client.protobuffs_pool.should_receive(:clear)
+      expect(@client.protobuffs_pool).to receive(:clear)
       @client.protobuffs_backend = :Beefcake
     end
 
     it "should raise an error when the chosen backend is not valid" do
-      Riak::Client::BeefcakeProtobuffsBackend.should_receive(:configured?).and_return(false)
-      lambda { @client.protobuffs { |x| } }.should raise_error
+      expect(Riak::Client::BeefcakeProtobuffsBackend).to receive(:configured?).and_return(false)
+      expect { @client.protobuffs { |x| } }.to raise_error
     end
   end
 
@@ -179,19 +83,9 @@ describe Riak::Client do
       @client = Riak::Client.new
     end
 
-    it "should use HTTP when the protocol is http or https" do
-      %w[http https].each do |p|
-        @client.protocol = p
-        @client.backend do |b|
-          b.should be_kind_of(Riak::Client::HTTPBackend)
-        end
-      end
-    end
-
     it "should use Protobuffs when the protocol is pbc" do
-      @client.protocol = "pbc"
       @client.backend do |b|
-        b.should be_kind_of(Riak::Client::ProtobuffsBackend)
+        expect(b).to be_kind_of(Riak::Client::ProtobuffsBackend)
       end
     end
   end
@@ -200,8 +94,8 @@ describe Riak::Client do
     before :each do
       @client = Riak::Client.new
       @bucket = @client.bucket('foo')
-      @bucket.should_receive(:[]).with('value1').and_return(mock('robject'))
-      @bucket.should_receive(:[]).with('value2').and_return(mock('robject'))
+      expect(@bucket).to receive(:[]).with('value1').and_return(double('robject'))
+      expect(@bucket).to receive(:[]).with('value2').and_return(double('robject'))
       @pairs = [
         [@bucket, 'value1'],
         [@bucket, 'value2']
@@ -209,37 +103,37 @@ describe Riak::Client do
     end
 
     it 'should accept an array of bucket and key pairs' do
-      lambda{ @client.get_many(@pairs) }.should_not raise_error
+      expect{ @client.get_many(@pairs) }.not_to raise_error
     end
 
     it 'should return a hash of bucket/key pairs and robjects' do
       @results = @client.get_many(@pairs)
-      @results.should be_a Hash
-      @results.length.should be(@pairs.length)
+      expect(@results).to be_a Hash
+      expect(@results.length).to be(@pairs.length)
     end
   end
 
   describe "retrieving a bucket" 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)
     end
 
     it "should return a bucket object" do
-      @client.bucket("foo").should be_kind_of(Riak::Bucket)
+      expect(@client.bucket("foo")).to be_kind_of(Riak::Bucket)
     end
 
     it "should fetch bucket properties if asked" do
-      @backend.should_receive(:get_bucket_props) {|b| b.name.should == "foo"; {} }
+      expect(@backend).to receive(:get_bucket_props) {|b| expect(b.name).to eq("foo"); {} }
       @client.bucket("foo", :props => true)
     end
 
     it "should memoize bucket parameters" do
-      @bucket = mock("Bucket")
-      Riak::Bucket.should_receive(:new).with(@client, "baz").once.and_return(@bucket)
-      @client.bucket("baz").should == @bucket
-      @client.bucket("baz").should == @bucket
+      @bucket = double("Bucket")
+      expect(Riak::Bucket).to receive(:new).with(@client, "baz").once.and_return(@bucket)
+      expect(@client.bucket("baz")).to eq(@bucket)
+      expect(@client.bucket("baz")).to eq(@bucket)
     end
 
     it "should reject buckets with zero-length names" do
@@ -250,224 +144,33 @@ describe Riak::Client do
   describe "listing buckets" do
     before 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)
     end
 
     after { Riak.disable_list_keys_warnings = true }
 
     it "should list buckets" do
-      @backend.should_receive(:list_buckets).and_return(%w{test test2})
+      expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
       buckets = @client.buckets
-      buckets.should have(2).items
-      buckets.should be_all {|b| b.is_a?(Riak::Bucket) }
-      buckets[0].name.should == "test"
-      buckets[1].name.should == "test2"
+      expect(buckets.size).to eq(2)
+      expect(buckets).to be_all {|b| b.is_a?(Riak::Bucket) }
+      expect(buckets[0].name).to eq("test")
+      expect(buckets[1].name).to eq("test2")
     end
 
     it "should warn about the expense of list-buckets when warnings are not disabled" do
       Riak.disable_list_keys_warnings = false
-      @backend.stub!(:list_buckets).and_return(%w{test test2})
-      @client.should_receive(:warn)
+      allow(@backend).to receive(:list_buckets).and_return(%w{test test2})
+      expect(@client).to receive(:warn)
       @client.buckets
     end
 
     it "should support a timeout option" do
-      @backend.should_receive(:list_buckets).with(timeout: 1234).and_return(%w{test test2})
+      expect(@backend).to receive(:list_buckets).with(timeout: 1234).and_return(%w{test test2})
 
       buckets = @client.buckets timeout: 1234
-      buckets.should have(2).items
-    end
-  end
-
-  describe "Luwak (large-files) support" do
-    describe "storing a file" do
-      before :each do
-        @client = Riak::Client.new
-        @http = mock(Riak::Client::HTTPBackend)
-        @http.stub!(:node).and_return(@client.node)
-        @client.stub!(:http).and_yield(@http)
-      end
-
-      it "should store the file via the HTTP interface" do
-        @http.should_receive(:store_file).with("text/plain", "Hello, world").and_return("123456789")
-        @client.store_file("text/plain", "Hello, world").should == "123456789"
-      end
-    end
-
-    describe "retrieving a file" do
-      before :each do
-        @client = Riak::Client.new
-        @http = mock(Riak::Client::HTTPBackend)
-        @http.stub!(:node).and_return(@client.node)
-        @client.stub!(:http).and_yield(@http)
-      end
-
-      it "should fetch via HTTP" do
-        @http.should_receive(:get_file).with("greeting.txt")
-        @client.get_file("greeting.txt")
-      end
-    end
-
-    it "should delete a file" do
-      @client = Riak::Client.new
-      @http = mock(Riak::Client::HTTPBackend)
-      @http.stub!(:node).and_return(@client.nodes.first)
-      @client.stub!(:http).and_yield(@http)
-      @http.should_receive(:delete_file).with("greeting.txt")
-      @client.delete_file("greeting.txt")
-    end
-
-    it "should detect if file exists via HTTP" do
-      @client = Riak::Client.new
-      @http = mock(Riak::Client::HTTPBackend)
-      @http.stub!(:node).and_return(@client.nodes.first)
-      @client.stub!(:http).and_yield(@http)
-      @http.should_receive(:file_exists?).and_return(true)
-      @client.file_exists?("foo").should be_true
-    end
-  end
-
-  describe "ssl", :ssl => true do
-    before :each do
-      @client = Riak::Client.new
-    end
-
-    it "should enable ssl when passed to the initializer" do
-      client = Riak::Client.new(:ssl => true)
-      client.nodes.first.ssl_options.should be_a(Hash)
-      client.nodes.first.ssl_options.should_not be_empty
-    end
-
-    it "should allow passing ssl options into the initializer" do
-      client = Riak::Client.new(:ssl => {:verify_mode => "peer"})
-      client.nodes.first.ssl_options.should be_a(Hash)
-      client.nodes.first.ssl_options[:verify_mode].should eq("peer")
-    end
-
-    it "should enable ssl options when initializing the client with https but not setting any ssl options" do
-      client = Riak::Client.new(:protocol => 'https')
-      client.nodes.first.ssl_options.should be_a(Hash)
-      client.nodes.first.ssl_options.should_not be_empty
-    end
-
-    it "should allow setting ssl options and specifying the https protocol" do
-      client = Riak::Client.new(:protocol => 'https', :ssl => {:verify_mode => 'peer'})
-      client.nodes.first.ssl_options.should be_a(Hash)
-      client.nodes.first.ssl_options[:verify_mode].should eq("peer")
-    end
-
-    it "should enable ssl options when setting the protocol to https but not setting any ssl options" do
-      @client.protocol = 'https'
-      @client.nodes.first.ssl_options.should be_a(Hash)
-      @client.nodes.first.ssl_options.should_not be_empty
-    end
-
-    it "should not have ssl options by default" do
-      @client.nodes.first.ssl_options.should be_nil
-    end
-
-    # The api should have an ssl= method for setting up all of the ssl
-    # options.  Once the ssl options have been assigned via `ssl=` they should
-    # be read back out using the read only `ssl_options`.  This is to provide
-    # a seperate api for setting ssl options via client configuration and
-    # reading them inside of a http backend.
-    it "should not allow reading ssl options via ssl" do
-      @client.should_not respond_to(:ssl)
-    end
-
-    it "should not allow writing ssl options via ssl_options=" do
-      @client.should_not respond_to(:ssl_options=)
-    end
-
-    it "should allow setting ssl to true" do
-      @client.ssl = true
-      @client.nodes.first.ssl_options[:verify_mode].should eq('none')
-    end
-
-    it "should allow setting ssl options as a hash" do
-      @client.ssl = {:verify_mode => "peer"}
-      @client.nodes.first.ssl_options[:verify_mode].should eq('peer')
-    end
-
-    it "should set the protocol to https when setting ssl to true" do
-      @client.ssl = true
-      @client.protocol.should eq("https")
-    end
-
-    it "should set the protocol to http when setting ssl to false" do
-      @client.protocol = 'https'
-      @client.ssl = false
-      @client.protocol.should eq('http')
-    end
-
-    it "should should clear ssl options when setting ssl to false" do
-      @client.ssl = true
-      @client.nodes.first.ssl_options.should_not be_nil
-      @client.ssl = false
-      @client.nodes.first.ssl_options.should be_nil
-    end
-
-    it "should set the protocol to https when setting ssl options" do
-      @client.ssl = {:verify_mode => "peer"}
-      @client.protocol.should eq("https")
-    end
-
-    it "should allow setting the verify_mode to none" do
-      @client.ssl = {:verify_mode => "none"}
-      @client.nodes.first.ssl_options[:verify_mode].should eq("none")
-    end
-
-    it "should allow setting the verify_mode to peer" do
-      @client.ssl = {:verify_mode => "peer"}
-      @client.nodes.first.ssl_options[:verify_mode].should eq("peer")
-    end
-
-    it "should not allow setting the verify_mode to anything else" do
-      lambda {@client.ssl = {:verify_mode => :your_mom}}.should raise_error(ArgumentError)
-    end
-
-    it "should default verify_mode to none" do
-      @client.ssl = true
-      @client.nodes.first.ssl_options[:verify_mode].should eq("none")
-    end
-
-    it "should allow setting the pem" do
-      @client.ssl = {:pem => 'i-am-a-pem'}
-      @client.nodes.first.ssl_options[:pem].should eq('i-am-a-pem')
-    end
-
-    it "should set them pem from the contents of pem_file" do
-      filepath = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test.pem'))
-      @client.ssl = {:pem_file => filepath}
-      @client.nodes.first.ssl_options[:pem].should eq("i-am-a-pem\n")
-    end
-
-    it "should allow setting the pem_password" do
-      @client.ssl = {:pem_password => 'pem-pass'}
-      @client.nodes.first.ssl_options[:pem_password].should eq('pem-pass')
-    end
-
-    it "should allow setting the ca_file" do
-      @client.ssl = {:ca_file => '/path/to/ca.crt'}
-      @client.nodes.first.ssl_options[:ca_file].should eq('/path/to/ca.crt')
-    end
-
-    it "should allow setting the ca_path" do
-      @client.ssl = {:ca_path => '/path/to/certs/'}
-      @client.nodes.first.ssl_options[:ca_path].should eq('/path/to/certs/')
-    end
-
-    %w[pem ca_file ca_path].each do |option|
-      it "should default the verify_mode to peer when setting the #{option}" do
-        @client.ssl = {option.to_sym => 'test-data'}
-        @client.nodes.first.ssl_options[:verify_mode].should eq("peer")
-      end
-
-      it "should allow setting the verify mode when setting the #{option}" do
-        @client.ssl = {option.to_sym => 'test-data', :verify_mode => "none"}
-        @client.nodes.first.ssl_options[:verify_mode].should eq("none")
-      end
+      expect(buckets.size).to eq(2)
     end
   end
 end