riak-client 2.0.0 → 2.1.0

data/spec/riak/beefcake_protobuffs_backend/object_methods_spec.rb

@@ -11,7 +11,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend::ObjectMethods do
   end
 
   describe "loading object data from the response" do
-    it "should load the key" do
+    it "loads the key" do
       content = double(:value => '', :vtag => nil, :content_type => nil, :links => nil, :usermeta => nil, :last_mod => nil, :indexes => nil, :charset => nil)
       pbuf = double(:vclock => nil, :content => [content], :value => nil, :key => 'akey')
       o = @backend.load_object(pbuf, @object)

data/spec/riak/beefcake_protobuffs_backend_spec.rb

@@ -17,7 +17,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       allow(TCPSocket).to receive(:new).and_return(@socket)
     end
 
-    it 'should raise an appropriate error when 2i is not available' do
+    it 'raises an appropriate error when 2i is not available' do
       expect(protocol).to receive(:write)
       expect(protocol).to receive(:expect).
         and_raise(
@@ -34,7 +34,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
     end
     
     context 'when streaming' do
-      it "should stream when a block is given" do 
+      it "streams when a block is given" do 
         expect(protocol).to receive(:write) do |msg, req|
           expect(msg).to eq(:IndexReq)
           expect(req[:stream]).to eq(true)
@@ -47,7 +47,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
         backend.get_index('bucket', 'words', 'asdf'..'hjkl', &blk)
       end
 
-      it "should send batches of results to the block" do
+      it "sends batches of results to the block" do
         expect(protocol).to receive(:write)
         
         response_sets = [%w{asdf asdg asdh}, %w{gggg gggh gggi}]
@@ -68,7 +68,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       end
     end
 
-    it "should return a full batch of results when not streaming" do
+    it "returns a full batch of results when not streaming" do
       expect(protocol).to receive(:write) do |msg, req|
         expect(msg).to eq(:IndexReq)
         expect(req[:stream]).not_to be
@@ -85,7 +85,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       expect(results).to eq(%w{asdf asdg asdh})
     end
 
-    it "should not crash out when no keys or terms are returned" do
+    it "returns no results when no keys or terms are returned" do
       expect(protocol).to receive(:write) do |msg, req|
         expect(msg).to eq(:IndexReq)
         expect(req[:stream]).not_to be
@@ -109,7 +109,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
   context "#mapred" do
     let(:mapred) { Riak::MapReduce.new(client).add('test').map("function(){}").map("function(){}") }
 
-    it "should not return nil for previous phases that don't return anything" do
+    it "returns empty sets for previous phases that don't return anything" do
       expect(protocol).to receive(:write)
 
       message = double(:message, :phase => 1, :response => [{}].to_json)
@@ -137,7 +137,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       end
     end
 
-    it "should set the if_none_match field when the object is new" do
+    it "sets the if_none_match field when the object is new" do
       expect(protocol).to receive(:write) do |msg, req|
         expect(msg).to eq(:PutReq)
         expect(req.if_none_match).to be_truthy
@@ -148,7 +148,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       backend.store_object(robject)
     end
 
-    it "should set the if_not_modified field when the object has a vclock" do
+    it "sets the if_not_modified field when the object has a vclock" do
       robject.vclock = Base64.encode64("foo")
       expect(protocol).to receive(:write) do |msg, req|
         expect(msg).to eq(:PutReq)

data/spec/riak/bucket_spec.rb

@@ -10,16 +10,16 @@ describe Riak::Bucket do
   end
 
   describe "when initializing" do
-    it "should require a client and a name" do
-      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
+    it "requires a client and a name" do
+      expect { Riak::Bucket.new }.to raise_error ArgumentError
+      expect { Riak::Bucket.new(@client) }.to raise_error ArgumentError
+      expect { Riak::Bucket.new("foo") }.to raise_error ArgumentError
+      expect { Riak::Bucket.new("foo", @client) }.to raise_error ArgumentError
       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
+    it "sets the client and name attributes" do
       bucket = Riak::Bucket.new(@client, "foo")
       expect(bucket.client).to eq(@client)
       expect(bucket.name).to eq("foo")
@@ -27,12 +27,12 @@ describe Riak::Bucket do
   end
 
   describe "accessing keys" do
-    it "should list the keys" do
+    it "lists the keys" do
       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
+    it "allows streaming keys through block" do
       expect(@backend).to receive(:list_keys).with(@bucket, {}).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
       all_keys = []
       @bucket.keys do |list|
@@ -41,12 +41,12 @@ describe Riak::Bucket do
       expect(all_keys).to eq(["bar", "baz"])
     end
 
-    it "should not cache the list of keys" do
+    it "fetches a fresh list of keys" do
       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
+    it "warns about the expense of list-keys when warnings are not disabled" do
       Riak.disable_list_keys_warnings = false
       allow(@backend).to receive(:list_keys).and_return(%w{test test2})
       expect(@bucket).to receive(:warn)
@@ -54,7 +54,7 @@ describe Riak::Bucket do
       Riak.disable_list_keys_warnings = true
     end
 
-    it "should allow a specified timeout when listing keys" do
+    it "allows a specified timeout when listing keys" do
       expect(@backend).to receive(:list_keys).with(@bucket, timeout: 1234).and_return(%w{bar})
 
       keys = @bucket.keys timeout: 1234
@@ -64,7 +64,7 @@ describe Riak::Bucket do
   end
 
   describe "accessing a counter" do
-    it "should return a counter object" do
+    it "returns a counter object" do
       expect(Riak::Counter).to receive(:new).with(@bucket, 'asdf').and_return('example counter')
       
       new_counter = @bucket.counter 'asdf'
@@ -74,31 +74,31 @@ describe Riak::Bucket do
   end
 
   describe "setting the bucket properties" do
-    it "should prefetch the properties when they are not present" do
+    it "prefetches the properties when they are not present" do
       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
+    it "sets the new properties on the bucket" do
       @bucket.instance_variable_set(:@props, {}) # Pretend they are there
       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
+    it "raises an error if an invalid type is given" do
       expect { @bucket.props = "blah" }.to raise_error(ArgumentError)
     end
   end
 
   describe "fetching the bucket properties" do
-    it "should fetch properties on first access" do
+    it "fetches properties on first access" do
       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
+    it "memoizes fetched properties" do
       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"})
@@ -106,7 +106,7 @@ describe Riak::Bucket do
   end
 
   describe "clearing the bucket properties" do
-    it "should make the request and delete the internal properties cache" do
+    it "sends the request and delete the internal properties cache" do
       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
@@ -114,17 +114,17 @@ describe Riak::Bucket do
   end
 
   describe "fetching an object" do
-    it "should fetch the object via the backend" do
+    it "fetches the object via the backend" do
       expect(@backend).to receive(:fetch_object).with(@bucket, "db", {}).and_return(nil)
       @bucket.get("db")
     end
 
-    it "should use the specified R quroum" do
+    it "uses the specified R quroum" do
       expect(@backend).to receive(:fetch_object).with(@bucket, "db", {:r => 2}).and_return(nil)
       @bucket.get("db", :r => 2)
     end
 
-    it "should disallow fetching an object with a zero-length key" do
+    it "disallows fetching an object with a zero-length key" do
       ## TODO: This actually tests the Client object, but there is no suite
       ## of tests for its generic interface.
       expect { @bucket.get('') }.to raise_error(ArgumentError)
@@ -132,7 +132,7 @@ describe Riak::Bucket do
   end
 
   describe "creating a new blank object" do
-    it "should instantiate the object with the given key, default to JSON" do
+    it "instantiates the object with the given key, default to JSON" do
       obj = @bucket.new('bar')
       expect(obj).to be_kind_of(Riak::RObject)
       expect(obj.key).to eq('bar')
@@ -144,25 +144,25 @@ describe Riak::Bucket 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
+    it "returns the existing object if present" do
       @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
+    it "creates a new blank object if the key does not exist" do
       expect(@backend).to receive(:fetch_object).and_raise(not_found_error)
       obj = @bucket.get_or_new('db')
       expect(obj.key).to eq('db')
       expect(obj.data).to be_blank
     end
 
-    it "should bubble up non-ok non-missing errors" do
+    it "bubbles up non-ok non-missing errors" do
       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
+    it "passes the given R quorum parameter to the backend" do
       @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)
@@ -170,7 +170,7 @@ describe Riak::Bucket do
   end
 
   describe "fetching multiple objects" do
-    it 'should get each object individually' do
+    it 'gets each object individually' do
       @object1 = double('obj1')
       @object2 = double('obj2')
       expect(@bucket).to receive(:[]).with('key1').and_return(@object1)
@@ -184,7 +184,7 @@ describe Riak::Bucket do
   end
 
   describe "querying an index" do
-    it "should list the matching keys" do
+    it "lists the matching keys" do
       expect(@backend).
         to receive(:get_index).
         with(@bucket, "test_bin", "testing", {return_terms: true}).
@@ -206,11 +206,11 @@ describe Riak::Bucket do
       allow(@backend).to receive(:get_bucket_props).and_return({"allow_mult" => false})
     end
 
-    it "should extract the allow_mult property" do
+    it "extracts the allow_mult property" do
       expect(@bucket.allow_mult).to be_falsey
     end
 
-    it "should set the allow_mult property" do
+    it "sets the allow_mult property" do
       expect(@bucket).to receive(:props=).with(hash_including('allow_mult' => true))
       @bucket.allow_mult = true
     end
@@ -221,11 +221,11 @@ describe Riak::Bucket do
       allow(@backend).to receive(:get_bucket_props).and_return({"n_val" => 3})
     end
 
-    it "should extract the N value" do
+    it "extracts the N value" do
       expect(@bucket.n_value).to eq(3)
     end
 
-    it "should set the N value" do
+    it "sets the N value" do
       expect(@bucket).to receive(:props=).with(hash_including('n_val' => 1))
       @bucket.n_value = 1
     end
@@ -237,11 +237,11 @@ describe Riak::Bucket do
         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
+      it "extracts the default #{q} quorum" do
         expect(@bucket.send(q)).to eq("quorum")
       end
 
-      it "should set the #{q} quorum" do
+      it "sets the #{q} quorum" do
         expect(@bucket).to receive(:props=).with(hash_including("#{q}" => 1))
         @bucket.send("#{q}=",1)
       end
@@ -249,12 +249,12 @@ describe Riak::Bucket do
   end
 
   describe "checking whether a key exists" do
-    it "should return true if the object does exist" do
+    it "returns true if the object does exist" do
       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
+    it "returns false if the object doesn't exist" do
       expect(@backend).to receive(:fetch_object).
         and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, "not found"))
       expect(@bucket.exists?("foo")).to be_falsey
@@ -262,12 +262,12 @@ describe Riak::Bucket do
   end
 
   describe "deleting an object" do
-    it "should delete a key from within the bucket" do
+    it "deletes a key from within the bucket" do
       expect(@backend).to receive(:delete_object).with(@bucket, "bar", {})
       @bucket.delete('bar')
     end
 
-    it "should use the specified RW quorum" do
+    it "uses the specified RW quorum" do
       expect(@backend).to receive(:delete_object).with(@bucket, "bar", {:rw => "all"})
       @bucket.delete('bar', :rw => "all")
     end

data/spec/riak/client_spec.rb

@@ -3,33 +3,33 @@ require 'riak/errors/protobuffs_error'
 
 describe Riak::Client, test_client: true do
   describe "when initializing" do
-    it "should default a single local node" do
+    it "defaults to a single local node" do
       client = Riak::Client.new
       expect(client.nodes).to eq([Riak::Client::Node.new(client)])
     end
 
-    it "should accept a host" do
+    it "accepts a host" do
       client = Riak::Client.new :host => "riak.basho.com"
       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
+    it "accepts a Protobuffs port" do
       client = Riak::Client.new :pb_port => 9000
       expect(client.nodes.size).to eq(1)
       expect(client.nodes.first.pb_port).to eq(9000)
     end
 
-    it "should accept a client ID" do
+    it "accepts a client ID" do
       client = Riak::Client.new :client_id => "AAAAAA=="
       expect(client.client_id).to eq("AAAAAA==")
     end
 
-    it "should create a client ID if not specified" do
+    it "creates a client ID if not specified" do
       expect(Riak::Client.new(pb_port: test_client.nodes.first.pb_port).client_id).not_to be_nil
     end
 
-    it "should accept multiple nodes" do
+    it "accepts multiple nodes" do
       client = Riak::Client.new :nodes => [
         {:host => 'riak1.basho.com'},
         {:host => 'riak2.basho.com', :pb_port => 1234},
@@ -40,7 +40,7 @@ describe Riak::Client, test_client: true do
     end
   end
 
-  it "should expose a Stamp object" do
+  it "exposes a Stamp object" do
     expect(subject).to respond_to(:stamp)
     expect(subject.stamp).to be_kind_of(Riak::Stamp)
   end
@@ -51,16 +51,16 @@ describe Riak::Client, test_client: true do
     end
 
     describe "setting the client id" do
-      it "should accept a string unmodified" do
+      it "accepts a string unmodified" do
         @client.client_id = "foo"
         expect(@client.client_id).to eq("foo")
       end
 
-      it "should reject an integer equal to the maximum client id" do
+      it "rejects an integer equal to the maximum client id" do
         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
+      it "rejects an integer larger than the maximum client id" do
         expect { @client.client_id = Riak::Client::MAX_CLIENT_ID + 1 }.to raise_error(ArgumentError)
       end
     end
@@ -71,21 +71,21 @@ describe Riak::Client, test_client: true do
       @client = Riak::Client.new
     end
 
-    it "should choose the selected backend" do
+    it "chooses the selected backend" do
       @client.protobuffs_backend = :Beefcake
       @client.protobuffs do |p|
         expect(p).to be_instance_of(Riak::Client::BeefcakeProtobuffsBackend)
       end
     end
 
-    it "should teardown the existing Protobuffs connections when changed" do
+    it "tears down the existing Protobuffs connections when changed" do
       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
+    it "raises an error when the chosen backend is not valid" do
       expect(Riak::Client::BeefcakeProtobuffsBackend).to receive(:configured?).and_return(false)
-      expect { @client.protobuffs { |x| } }.to raise_error
+      expect { @client.protobuffs { |x| } }.to raise_error Riak::BackendCreationError
     end
   end
 
@@ -94,7 +94,7 @@ describe Riak::Client, test_client: true do
       @client = Riak::Client.new
     end
 
-    it "should use Protobuffs when the protocol is pbc" do
+    it "uses Protobuffs when the protocol is pbc" do
       @client.backend do |b|
         expect(b).to be_kind_of(Riak::Client::ProtobuffsBackend)
       end
@@ -113,11 +113,11 @@ describe Riak::Client, test_client: true do
       ]
     end
 
-    it 'should accept an array of bucket and key pairs' do
+    it 'accepts an array of bucket and key pairs' do
       expect{ @client.get_many(@pairs) }.not_to raise_error
     end
 
-    it 'should return a hash of bucket/key pairs and robjects' do
+    it 'returns a hash of bucket/key pairs and robjects' do
       @results = @client.get_many(@pairs)
       expect(@results).to be_a Hash
       expect(@results.length).to be(@pairs.length)
@@ -131,23 +131,23 @@ describe Riak::Client, test_client: true do
       allow(@client).to receive(:backend).and_yield(@backend)
     end
 
-    it "should return a bucket object" do
+    it "returns a bucket object" do
       expect(@client.bucket("foo")).to be_kind_of(Riak::Bucket)
     end
 
-    it "should fetch bucket properties if asked" do
+    it "fetches bucket properties if asked" do
       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
+    it "memoizes bucket parameters" do
       @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
+    it "rejects buckets with zero-length names" do
       expect { @client.bucket('') }.to raise_error(ArgumentError)
     end
   end
@@ -161,7 +161,7 @@ describe Riak::Client, test_client: true do
 
     after { Riak.disable_list_keys_warnings = true }
 
-    it "should list buckets" do
+    it "lists buckets" do
       expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
       buckets = @client.buckets
       expect(buckets.size).to eq(2)
@@ -170,14 +170,14 @@ describe Riak::Client, test_client: true do
       expect(buckets[1].name).to eq("test2")
     end
 
-    it "should warn about the expense of list-buckets when warnings are not disabled" do
+    it "warns about the expense of list-buckets when warnings are not disabled" do
       Riak.disable_list_keys_warnings = false
       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
+    it "supports a timeout option" do
       expect(@backend).to receive(:list_buckets).with(timeout: 1234).and_return(%w{test test2})
 
       buckets = @client.buckets timeout: 1234
@@ -190,7 +190,7 @@ describe Riak::Client, test_client: true do
       @client = Riak::Client.new 
     end
 
-    it "should retry on recoverable errors" do
+    it "retries on recoverable errors" do
       call_count = 0
       
       begin
@@ -204,7 +204,7 @@ describe Riak::Client, test_client: true do
       expect(call_count).to eq(3)
     end
 
-    it "should throw a RuntimeError if it runs out of retries" do
+    it "throws a RuntimeError if it runs out of retries" do
       error = nil
       begin
         @client.backend do |b| 
@@ -217,5 +217,4 @@ describe Riak::Client, test_client: true do
       expect(error).not_to be_nil
       expect(error).to be_instance_of(RuntimeError)
     end
-
 end