riak-client 2.0.0 → 2.1.0

data/spec/riak/escape_spec.rb

@@ -7,7 +7,7 @@ describe Riak::Util::Escape do
     @object.extend(Riak::Util::Escape)
   end
 
-  it "should use URI by default for escaping" do
+  it "uses URI by default for escaping" do
     expect(Riak.escaper).to eq(URI)
   end
 
@@ -15,21 +15,21 @@ describe Riak::Util::Escape do
     before { @oldesc, Riak.escaper = Riak.escaper, CGI }
     after { Riak.escaper = @oldesc }
 
-    it "should escape standard non-safe characters" do
+    it "escapes standard non-safe characters" do
       expect(@object.escape("some string")).to eq("some%20string")
       expect(@object.escape("another^one")).to eq("another%5Eone")
       expect(@object.escape("bracket[one")).to eq("bracket%5Bone")
     end
 
-    it "should escape slashes" do
+    it "escapes slashes" do
       expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
     end
 
-    it "should convert the bucket or key to a string before escaping" do
+    it "converts the bucket or key to a string before escaping" do
       expect(@object.escape(125)).to eq('125')
     end
 
-    it "should unescape escaped strings" do
+    it "unescapes escaped strings" do
       expect(@object.unescape("some%20string")).to eq("some string")
       expect(@object.unescape("another%5Eone")).to eq("another^one")
       expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")
@@ -41,26 +41,26 @@ describe Riak::Util::Escape do
     before { @oldesc, Riak.escaper = Riak.escaper, URI }
     after { Riak.escaper = @oldesc }
 
-    it "should escape standard non-safe characters" do
+    it "escapes standard non-safe characters" do
       expect(@object.escape("some string")).to eq("some%20string")
       expect(@object.escape("another^one")).to eq("another%5Eone")
       expect(@object.escape("--one+two--")).to eq("--one%2Btwo--")
     end
 
-    it "should allow URI-safe characters" do
+    it "allows URI-safe characters" do
       expect(@object.escape("bracket[one")).to eq("bracket[one")
       expect(@object.escape("sean@basho")).to eq("sean@basho")
     end
 
-    it "should escape slashes" do
+    it "escapes slashes" do
       expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
     end
 
-    it "should convert the bucket or key to a string before escaping" do
+    it "converts the bucket or key to a string before escaping" do
       expect(@object.escape(125)).to eq('125')
     end
 
-    it "should unescape escaped strings" do
+    it "unescapes escaped strings" do
       expect(@object.unescape("some%20string")).to eq("some string")
       expect(@object.unescape("another%5Eone")).to eq("another^one")
       expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")

data/spec/riak/feature_detection_spec.rb

@@ -10,7 +10,7 @@ describe Riak::Client::FeatureDetection do
   subject { klass.new }
 
   context "when the get_server_version is unimplemented" do
-    it "should raise a NotImplementedError" do
+    it "raises a NotImplementedError" do
       expect { subject.server_version }.to raise_error(NotImplementedError)
     end
   end

data/spec/riak/index_collection_spec.rb

@@ -2,14 +2,15 @@ require 'spec_helper'
 
 describe Riak::IndexCollection do
   describe "json initialization" do
-    it "should accept a list of keys" do
+    it "accepts a list of keys" do
       @input = {
         'keys' => %w{first second third}
       }.to_json
       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
+
+    it "accepts a list of keys and a continuation" do
       @input = {
         'keys' => %w{first second third},
         'continuation' => 'examplecontinuation'
@@ -18,7 +19,8 @@ describe Riak::IndexCollection do
       expect(%w{first second third}).to eq(@coll)
       expect(@coll.continuation).to eq('examplecontinuation')
     end
-    it "should accept a list of results hashes" do
+
+    it "accepts a list of results hashes" do
       @input = {
         'results' => [
           {'first' => 'first'},
@@ -31,7 +33,8 @@ describe Riak::IndexCollection do
       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
+
+    it "accepts a list of results hashes and a continuation" do
       @input = {
         'results' => [
           {'first' => 'first'},

data/spec/riak/instrumentation_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Riak::Client do
+
+  before do
+    @client = Riak::Client.new
+    @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")
+
+    @events = []
+    @notifier = ActiveSupport::Notifications.notifier
+    @notifier.subscribe { |*args| (@events ||= []) << event(*args) }
+  end
+
+  describe "instrumentation", instrumentation: true do
+
+    it "should notify on the 'buckets' operation" do
+      expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
+      test_client_event(@client, 'riak.list_buckets') do
+        @client.buckets
+      end
+    end
+
+    it "should notify on the 'list_buckets' operation" do
+      expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
+      test_client_event(@client, 'riak.list_buckets') do
+        @client.list_buckets
+      end
+    end
+
+    it "should notify on the 'list_keys' operation" do
+      expect(@backend).to receive(:list_keys).and_return(%w{test test2})
+      test_client_event(@client, 'riak.list_keys') do
+        @client.list_keys(@bucket)
+      end
+    end
+
+    it "should notify on the 'get_bucket_props' operation" do
+      expect(@backend).to receive(:get_bucket_props).and_return({})
+      test_client_event(@client, 'riak.get_bucket_props') do
+        @client.get_bucket_props(@bucket)
+      end
+    end
+
+    it "should notify on the 'set_bucket_props' operation" do
+      expect(@backend).to receive(:set_bucket_props).and_return({})
+      test_client_event(@client, 'riak.set_bucket_props') do
+        @client.set_bucket_props(@bucket, {})
+      end
+    end
+
+    it "should notify on the 'clear_bucket_props' operation" do
+      expect(@backend).to receive(:reset_bucket_props).and_return({})
+      test_client_event(@client, 'riak.clear_bucket_props') do
+        @client.clear_bucket_props(@bucket)
+      end
+    end
+
+    it "should notify on the 'get_index' operation" do
+      expect(@backend).to receive(:get_index).and_return({})
+      test_client_event(@client, 'riak.get_index') do
+        @client.get_index(@bucket, 'index', 'query', {})
+      end
+    end
+
+    it "should notify on the 'get_object' operation" do
+      expect(@backend).to receive(:fetch_object).and_return(nil)
+      test_client_event(@client, 'riak.get_object') do
+        @client.get_object(@bucket, 'bar')
+      end
+    end
+
+    it "should notify on the 'store_object' operation" do
+      expect(@backend).to receive(:store_object).and_return(nil)
+      test_client_event(@client, 'riak.store_object') do
+        @client.store_object(Object.new)
+      end
+    end
+
+    it "should notify on the 'reload_object' operation" do
+      expect(@backend).to receive(:reload_object).and_return(nil)
+      test_client_event(@client, 'riak.reload_object') do
+        @client.reload_object(Object.new)
+      end
+    end
+
+    it "should notify on the 'delete_object' operation" do
+      expect(@backend).to receive(:delete_object).and_return(nil)
+      test_client_event(@client, 'riak.delete_object') do
+        @client.delete_object(@bucket, 'bar')
+      end
+    end
+
+    it "should notify on the 'mapred' operation" do
+      @mapred = Riak::MapReduce.new(@client).add('test').map("function(){}").map("function(){}")
+      expect(@backend).to receive(:mapred).and_return(nil)
+      test_client_event(@client, 'riak.map_reduce') do
+        @client.mapred(@mapred)
+      end
+    end
+
+    it "should notify on the 'ping' operation" do
+      expect(@backend).to receive(:ping).and_return(nil)
+      test_client_event(@client, 'riak.ping') do
+        @client.ping
+      end
+    end
+  end
+end
+
+def test_client_event(client, event_name, &block)
+  block.call
+  expect(@events.size).to eql(1)
+  event = @events.first
+  expect(event.name).to eql(event_name)
+  expect(event.payload[:client_id]).to eql(client.client_id)
+end
+
+# name, start, finish, id, payload
+def event(*args)
+  ActiveSupport::Notifications::Event.new(*args)
+end

data/spec/riak/link_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe Riak::Link do
   describe "parsing a link header" do
-    it "should create Link objects from the data" do
+    it "creates Link objects from the data" do
       result = Riak::Link.parse('</riak/foo/bar>; rel="tag", </riak/foo>; rel="up"')
       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
+    it "sets the bucket, key, url and rel parameters properly" do
       result = Riak::Link.parse('</riak/foo/bar>; riaktag="tag", </riak/foo>; rel="up"')
       expect(result[0].url).to eq("/riak/foo/bar")
       expect(result[0].bucket).to eq("foo")
@@ -20,14 +20,14 @@ describe Riak::Link do
       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
+    it "keeps 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"')
       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
+    it "parses the Riak 1.0 URL scheme" do
       result = Riak::Link.parse('</buckets/b/keys/k>; riaktag="tag"').first
       expect(result.bucket).to eq('b')
       expect(result.key).to eq('k')
@@ -36,24 +36,24 @@ describe Riak::Link do
   end
 
   context "converting to a string" do
-    it "should convert to a string appropriate for use in the Link header" do
+    it "to a string appropriate for use in the Link header" do
       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
+    it "converts to a string using the new URL scheme" do
       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
+  it "converts to a walk spec when pointing to an object" do
     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
+  it "is 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")
     expect(one).to eq(two)
@@ -61,21 +61,21 @@ describe Riak::Link do
     expect([two]).to include(one)
   end
 
-  it "should unescape the bucket name" do
+  it "unescapes the bucket name" do
     expect(Riak::Link.new("/riak/bucket%20spaces/key", "foo").bucket).to eq("bucket spaces")
   end
 
-  it "should unescape the key name" do
+  it "unescapes the key name" do
     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
+  it "doesn't rely on the prefix to equal /riak/ when extracting the bucket and key" do
     link = Riak::Link.new("/raw/bucket/key", "foo")
     expect(link.bucket).to eq("bucket")
     expect(link.key).to eq("key")
   end
 
-  it "should construct from bucket, key and tag" do
+  it "constructs from bucket, key and tag" do
     link = Riak::Link.new("bucket", "key", "tag")
     expect(link.bucket).to eq("bucket")
     expect(link.key).to eq("key")

data/spec/riak/list_buckets_spec.rb

@@ -13,7 +13,7 @@ describe Riak::ListBuckets do
   end
 
   describe "non-streaming" do
-    it 'should call the backend without a block' do
+    it 'calls the backend without a block' do
       @expect_list.with({}).and_return(%w{a b c d})
 
       @client.list_buckets
@@ -21,7 +21,7 @@ describe Riak::ListBuckets do
   end
 
   describe "streaming" do
-    it 'should call the backend with a block' do
+    it 'calls the backend with a block' do
       @expect_list.
         and_yield(%w{abc abd abe}).
         and_yield(%w{bbb ccc ddd})

data/spec/riak/map_reduce/filter_builder_spec.rb

@@ -2,19 +2,19 @@ require 'spec_helper'
 
 describe Riak::MapReduce::FilterBuilder do
   subject { Riak::MapReduce::FilterBuilder.new }
-  it "should evaluate the passed block on initialization" do
+  it "evaluates the passed block on initialization" do
     expect(subject.class.new do
       matches "foo"
     end.to_a).to eq([[:matches, "foo"]])
   end
 
-  it "should add filters to the list" do
+  it "adds filters to the list" do
     subject.to_lower
     subject.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
+  it "adds a logical operation with a block" do
     subject.OR do
       starts_with "foo"
       ends_with "bar"
@@ -22,11 +22,11 @@ describe Riak::MapReduce::FilterBuilder do
     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
+  it "raises an error on a filter arity mismatch" do
     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
+  it "raises an error when a block is not given to a logical operation" do
     expect { subject._or }.to raise_error(ArgumentError)
   end
 end

data/spec/riak/map_reduce/phase_spec.rb

@@ -6,53 +6,53 @@ describe Riak::MapReduce::Phase do
     @erl_fun = "fun(Obj, _KeyData, _Arg) -> [{riak_object:key(Obj), riak_object:get_value(Obj)}] end."
   end
 
-  it "should initialize with a type and a function" do
+  it "initializes with a type and a function" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => @js_fun, :language => "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
+  it "initializes with a type and an MF" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"], :language => "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
+  it "initializes with a type and a bucket/key" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "funs", :key => "awesome_map"}, :language => "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
+  it "assumes the language is erlang when the function is an array" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"])
     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
+  it "assumes 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)
     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
+  it "assumes 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)
     expect(phase.language).to eq("erlang")
   end
 
-  it "should assume the language is javascript when the function is a hash" do
+  it "assumes the language is javascript when the function is a hash" do
     phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "jobs", :key => "awesome_map"})
     expect(phase.language).to eq("javascript")
   end
 
-  it "should accept a WalkSpec for the function when a link phase" do
+  it "accepts a WalkSpec for the function when a link phase" do
     phase = Riak::MapReduce::Phase.new(:type => :link, :function => Riak::WalkSpec.new({}))
     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
+  it "raises an error if a WalkSpec is given for a phase type other than :link" do
     expect { Riak::MapReduce::Phase.new(:type => :map, :function => Riak::WalkSpec.new({})) }.to raise_error(ArgumentError)
   end
 
@@ -67,39 +67,39 @@ describe Riak::MapReduce::Phase do
           @phase.type = type
         end
 
-        it "should be an object with a single key of '#{type}'" do
+        it "is an object with a single key of '#{type}'" do
           expect(@phase.to_json).to match(/^\{"#{type}":/)
         end
 
-        it "should include the language" do
+        it "includes the language" do
           expect(@phase.to_json).to match(/"language":/)
         end
 
-        it "should include the keep value" do
+        it "includes the keep value" do
           expect(@phase.to_json).to match(/"keep":false/)
           @phase.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
+        it "includes the function source when the function is a source string" do
           @phase.function = "function(v,_,_){ return v; }"
           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
+        it "includes the function name when the function is not a lambda" do
           @phase.function = "Riak.mapValues"
           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
+        it "includes the bucket and key when referring to a stored function" do
           @phase.function = {:bucket => "design", :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
+        it "includes the module and function when invoking an Erlang function" do
           @phase.function = ["riak_mapreduce", "mapreduce_fun"]
           expect(@phase.to_json).to include('"module":"riak_mapreduce"')
           expect(@phase.to_json).to include('"function":"mapreduce_fun"')
@@ -113,23 +113,23 @@ describe Riak::MapReduce::Phase do
         @phase.function = {}
       end
 
-      it "should be an object of a single key 'link'" do
+      it "is an object of a single key 'link'" do
         expect(@phase.to_json).to match(/^\{"link":/)
       end
 
-      it "should include the bucket" do
+      it "includes the bucket" do
         expect(@phase.to_json).to match(/"bucket":"_"/)
         @phase.function[:bucket] = "foo"
         expect(@phase.to_json).to match(/"bucket":"foo"/)
       end
 
-      it "should include the tag" do
+      it "includes the tag" do
         expect(@phase.to_json).to match(/"tag":"_"/)
         @phase.function[:tag] = "parent"
         expect(@phase.to_json).to match(/"tag":"parent"/)
       end
 
-      it "should include the keep value" do
+      it "includes the keep value" do
         expect(@phase.to_json).to match(/"keep":false/)
         @phase.keep = true
         expect(@phase.to_json).to match(/"keep":true/)