riak-client 2.2.0.pre1 → 2.2.0

data/spec/riak/map_reduce/filter_builder_spec.rb

@@ -11,7 +11,7 @@ describe Riak::MapReduce::FilterBuilder 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]])
+    expect(subject.to_a).to eq([[:to_lower], [:similar_to, "ripple", 3]])
   end
 
   it "adds a logical operation with a block" do
@@ -19,7 +19,7 @@ describe Riak::MapReduce::FilterBuilder do
       starts_with "foo"
       ends_with "bar"
     end
-    expect(subject.to_a).to eq([[:or, [[:starts_with, "foo"],[:ends_with, "bar"]]]])
+    expect(subject.to_a).to eq([[:or, [[:starts_with, "foo"], [:ends_with, "bar"]]]])
   end
 
   it "raises an error on a filter arity mismatch" do

data/spec/riak/map_reduce/phase_spec.rb

@@ -14,9 +14,9 @@ describe Riak::MapReduce::Phase do
   end
 
   it "initializes with a type and an MF" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"], :language => "erlang")
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => %w(module function), :language => "erlang")
     expect(phase.type).to eq(:map)
-    expect(phase.function).to eq(["module", "function"])
+    expect(phase.function).to eq(%w(module function))
     expect(phase.language).to eq("erlang")
   end
 
@@ -28,7 +28,7 @@ describe Riak::MapReduce::Phase do
   end
 
   it "assumes the language is erlang when the function is an array" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => ["module", "function"])
+    phase = Riak::MapReduce::Phase.new(:type => :map, :function => %w(module function))
     expect(phase.language).to eq("erlang")
   end
 
@@ -100,7 +100,7 @@ describe Riak::MapReduce::Phase do
         end
 
         it "includes the module and function when invoking an Erlang function" do
-          @phase.function = ["riak_mapreduce", "mapreduce_fun"]
+          @phase.function = %w(riak_mapreduce mapreduce_fun)
           expect(@phase.to_json).to include('"module":"riak_mapreduce"')
           expect(@phase.to_json).to include('"function":"mapreduce_fun"')
         end

data/spec/riak/map_reduce_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Riak::MapReduce do
-  
+
   let(:backend){ double 'Backend' }
   let(:client) do
     Riak::Client.new.tap do |c|
@@ -42,20 +42,20 @@ describe Riak::MapReduce do
     end
 
     it "adds bucket/key pairs to the inputs" do
-      mr.add("foo","bar")
-      expect(mr.inputs).to eq([["foo","bar"]])
+      mr.add("foo", "bar")
+      expect(mr.inputs).to eq([%w(foo bar)])
     end
 
     it "adds an array containing a bucket/key pair to the inputs" do
-      mr.add(["foo","bar"])
-      expect(mr.inputs).to eq([["foo","bar"]])
+      mr.add(%w(foo bar))
+      expect(mr.inputs).to eq([%w(foo bar)])
     end
 
     it "adds an object to the inputs by its bucket and key" do
       bucket = Riak::Bucket.new(client, "foo")
       obj = Riak::RObject.new(bucket, "bar")
       mr.add(obj)
-      expect(mr.inputs).to eq([["foo", "bar"]])
+      expect(mr.inputs).to eq([%w(foo bar)])
     end
 
     it 'adds a bucket-typed object to the inputs' do
@@ -68,8 +68,8 @@ describe Riak::MapReduce do
     end
 
     it "adds an array containing a bucket/key/key-data triple to the inputs" do
-      mr.add(["foo","bar",1000])
-      expect(mr.inputs).to eq([["foo","bar",1000]])
+      mr.add(["foo", "bar", 1000])
+      expect(mr.inputs).to eq([["foo", "bar", 1000]])
     end
 
     it "uses a bucket name as the single input" do
@@ -90,8 +90,14 @@ describe Riak::MapReduce do
     end
 
     it "accepts a list of key-filters along with a bucket" do
-      mr.add("foo", [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]])
-      expect(mr.inputs).to eq({:bucket => "foo", :key_filters => [[:tokenize, "-", 3], [:string_to_int], [:between, 2009, 2010]]})
+      mr.add("foo",
+             [[:tokenize, "-", 3],
+              [:string_to_int],
+              [:between, 2009, 2010]])
+      expect(mr.inputs).to eq({bucket: "foo",
+                               key_filters: [[:tokenize, "-", 3],
+                                             [:string_to_int],
+                                             [:between, 2009, 2010]]})
     end
 
     it 'accepts a list of key-filters along with a bucket-typed bucket' do
@@ -104,7 +110,7 @@ describe Riak::MapReduce do
       mr.add(typed_bucket, filters)
 
       expect(mr.inputs).to eq(
-                              bucket: [typed_bucket.type.name, 
+                              bucket: [typed_bucket.type.name,
                                        typed_bucket.name],
                               key_filters: filters
                               )
@@ -116,23 +122,35 @@ describe Riak::MapReduce do
         string_to_int
         between 2009, 2010
       end
-      expect(mr.inputs).to eq({: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 "sets the inputs for equality" do
         expect(mr.index("foo", "email_bin", "sean@basho.com")).to eq(mr)
-        expect(mr.inputs).to eq({:bucket => "foo", :index => "email_bin", :key => "sean@basho.com"})
+        expect(mr.inputs).to eq(bucket: "foo",
+                                index: "email_bin",
+                                key: "sean@basho.com")
       end
 
       it "sets the inputs for a range" do
         expect(mr.index("foo", "rank_int", 10..20)).to eq(mr)
-        expect(mr.inputs).to eq({:bucket => "foo", :index => "rank_int", :start => 10, :end => 20})
+        expect(mr.inputs).to eq(bucket: "foo",
+                                index: "rank_int",
+                                start: 10,
+                                end: 20)
       end
 
       it "raises an error when given an invalid query" do
-        expect { mr.index("foo", "rank_int", 1.0348) }.to raise_error(ArgumentError)
-        expect { mr.index("foo", "rank_int", Range.new(1.03, 1.05)) }.to raise_error(ArgumentError)
+        expect do
+          mr.index("foo", "rank_int", 1.0348)
+        end.to raise_error(ArgumentError)
+        expect do
+          mr.index("foo", "rank_int", Range.new(1.03, 1.05))
+        end.to raise_error(ArgumentError)
       end
     end
 
@@ -145,13 +163,13 @@ describe Riak::MapReduce do
         after { Riak.url_decoding = @urldecode }
 
         it "adds bucket/key pairs to the inputs with bucket and key escaped" do
-          mr.add("[foo]","(bar)")
-          expect(mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
+          mr.add("[foo]", "(bar)")
+          expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
         end
 
         it "adds an escaped array containing a bucket/key pair to the inputs" do
-          mr.add(["[foo]","(bar)"])
-          expect(mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
+          mr.add(["[foo]", "(bar)"])
+          expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
         end
 
         it "adds an object to the inputs by its escaped bucket and key" do
@@ -162,8 +180,8 @@ describe Riak::MapReduce do
         end
 
         it "adds an escaped array containing a bucket/key/key-data triple to the inputs" do
-          mr.add(["[foo]","(bar)","[]()"])
-          expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29","[]()"]])
+          mr.add(["[foo]", "(bar)", "[]()"])
+          expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29", "[]()"]])
         end
 
         it "uses an escaped bucket name as the single input" do
@@ -179,25 +197,25 @@ describe Riak::MapReduce do
         after { Riak.url_decoding = @urldecode }
 
         it "adds bucket/key pairs to the inputs with bucket and key unescaped" do
-          mr.add("[foo]","(bar)")
-          expect(mr.inputs).to eq([["[foo]","(bar)"]])
+          mr.add("[foo]", "(bar)")
+          expect(mr.inputs).to eq([["[foo]", "(bar)"]])
         end
 
         it "adds an unescaped array containing a bucket/key pair to the inputs" do
-          mr.add(["[foo]","(bar)"])
-          expect(mr.inputs).to eq([["[foo]","(bar)"]])
+          mr.add(["[foo]", "(bar)"])
+          expect(mr.inputs).to eq([["[foo]", "(bar)"]])
         end
 
         it "adds an object to the inputs by its unescaped bucket and key" do
           bucket = Riak::Bucket.new(client, "[foo]")
           obj = Riak::RObject.new(bucket, "(bar)")
           mr.add(obj)
-          expect(mr.inputs).to eq([["[foo]","(bar)"]])
+          expect(mr.inputs).to eq([["[foo]", "(bar)"]])
         end
 
         it "adds an unescaped array containing a bucket/key/key-data triple to the inputs" do
-          mr.add(["[foo]","(bar)","[]()"])
-          expect(mr.inputs).to eq([["[foo]","(bar)","[]()"]])
+          mr.add(["[foo]", "(bar)", "[]()"])
+          expect(mr.inputs).to eq([["[foo]", "(bar)", "[]()"]])
         end
 
         it "uses an unescaped bucket name as the single input" do
@@ -214,13 +232,13 @@ describe Riak::MapReduce do
       after { Riak.escaper = @oldesc }
 
       it "adds bucket/key pairs to the inputs with bucket and key escaped" do
-        mr.add("[foo]","(bar)")
-        expect(mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
+        mr.add("[foo]", "(bar)")
+        expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
       end
 
       it "adds an escaped array containing a bucket/key pair to the inputs" do
-        mr.add(["[foo]","(bar)"])
-        expect(mr.inputs).to eq([["%5Bfoo%5D","%28bar%29"]])
+        mr.add(["[foo]", "(bar)"])
+        expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29"]])
       end
 
       it "adds an object to the inputs by its escaped bucket and key" do
@@ -231,8 +249,8 @@ describe Riak::MapReduce do
       end
 
       it "adds an escaped array containing a bucket/key/key-data triple to the inputs" do
-        mr.add(["[foo]","(bar)","[]()"])
-        expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29","[]()"]])
+        mr.add(["[foo]", "(bar)", "[]()"])
+        expect(mr.inputs).to eq([["%5Bfoo%5D", "%28bar%29", "[]()"]])
       end
 
       it "uses an escaped bucket name as the single input" do
@@ -284,19 +302,19 @@ describe Riak::MapReduce do
       end
 
       it "accepts a module/function pair" do
-        mr.send(type, ["riak","mapsomething"])
+        mr.send(type, %w(riak mapsomething))
         expect(mr.query.size).to eq(1)
         phase = mr.query.first
-        expect(phase.function).to eq(["riak", "mapsomething"])
+        expect(phase.function).to eq(%w(riak mapsomething))
         expect(phase.type).to eq(type)
         expect(phase.language).to eq("erlang")
       end
 
       it "accepts a module/function pair with extra options" do
-        mr.send(type, ["riak", "mapsomething"], :arg => [1000])
+        mr.send(type, %w(riak mapsomething), :arg => [1000])
         expect(mr.query.size).to eq(1)
         phase = mr.query.first
-        expect(phase.function).to eq(["riak", "mapsomething"])
+        expect(phase.function).to eq(%w(riak mapsomething))
         expect(phase.type).to eq(type)
         expect(phase.language).to eq("erlang")
         expect(phase.arg).to eq([1000])
@@ -356,7 +374,7 @@ describe Riak::MapReduce do
     end
 
     it "emits an array of inputs when there are multiple inputs" do
-      mr.add("foo","bar",1000).add("foo","baz")
+      mr.add("foo", "bar", 1000).add("foo", "baz")
       expect(mr.to_json).to include('"inputs":[["foo","bar",1000],["foo","baz"]]')
     end
 
@@ -372,7 +390,7 @@ describe Riak::MapReduce do
 
   describe "executing the map reduce job" do
     before :each do
-      mr.map("Riak.mapValues",:keep => true)
+      mr.map("Riak.mapValues", :keep => true)
     end
 
     it "submits the query to the backend" do
@@ -384,7 +402,7 @@ describe Riak::MapReduce do
       arr = []
       expect(backend).to receive(:mapred).with(mr).and_yield("foo").and_yield("bar")
       mr.run {|v| arr << v }
-      expect(arr).to eq(["foo", "bar"])
+      expect(arr).to eq(%w(foo bar))
     end
 
     it "interprets failed requests with JSON content-types as map reduce errors" do

data/spec/riak/multiget_spec.rb

@@ -42,7 +42,7 @@ describe Riak::Multiget do
 
       expect(@multiget.finished?).to be_falsey
 
-      # allow fetch 
+      # allow fetch
       @slow_mtx.unlock
 
       @results = @multiget.results
@@ -70,7 +70,7 @@ describe Riak::Multiget do
     it "returns a hash of pairs to values" do
       expect(@bucket).to receive(:[]).with('key1')
       expect(@bucket).to receive(:[]).with('key2')
-      
+
       @multiget = Riak::Multiget.new(@client, @pairs)
       @multiget.fetch
       @results = @multiget.results

data/spec/riak/robject_spec.rb

@@ -147,13 +147,13 @@ describe Riak::RObject do
                             "vclock"=> "a85hYGBgzmDKBVIsCfs+fc9gSN9wlA8q/hKosDpIOAsA",
                             "values"=> [
                                         {"metadata"=>
-                                          {"Links"=>[["addresses", "A2cbUQ2KEMbeyWGtdz97LoTi1DN", "home_address"]],
+                                          {"Links"=>[%w(addresses A2cbUQ2KEMbeyWGtdz97LoTi1DN home_address)],
                                             "X-Riak-VTag"=>"5bnavU3rrubcxLI8EvFXhB",
                                             "content-type"=>"application/json",
                                             "X-Riak-Last-Modified"=>"Mon, 12 Jul 2010 21:37:43 GMT",
                                             "X-Riak-Meta"=>{"X-Riak-Meta-King-Of-Robots"=>"I"},
                                             "index" => {
-                                              "email_bin" => ["sean@basho.com","seancribbs@gmail.com"],
+                                              "email_bin" => ["sean@basho.com", "seancribbs@gmail.com"],
                                               "rank_int" => 50
                                             }
                                           },
@@ -163,7 +163,7 @@ describe Riak::RObject do
                                        ]
                           }
                          ]
-      @object = Riak::RObject.load_from_mapreduce(@client,@sample_response).first
+      @object = Riak::RObject.load_from_mapreduce(@client, @sample_response).first
       expect(@object).to be_kind_of(Riak::RObject)
     end
 
@@ -181,6 +181,7 @@ describe Riak::RObject do
 
     it "sets the vclock" do
       expect(@object.vclock).to eq("a85hYGBgzmDKBVIsCfs+fc9gSN9wlA8q/hKosDpIOAsA")
+      expect(@object.causal_context).to eq @object.vclock
     end
 
     it "loads and parse links" do
@@ -274,17 +275,31 @@ describe Riak::RObject do
     end
 
     it "raises an error when the content_type is blank" do
-      expect { @object.content_type = nil; @object.store }.to raise_error(ArgumentError)
-      expect { @object.content_type = "   "; @object.store }.to raise_error(ArgumentError)
+      expect do
+        @object.content_type = nil
+        @object.store
+      end.to raise_error(ArgumentError)
+      expect do
+        @object.content_type = '   '
+        @object.store
+      end.to raise_error(ArgumentError)
     end
 
     it "raises an error when given an empty string as key" do
-      expect { @object.key = ''; @object.store }.to raise_error(ArgumentError)
+      expect do
+        @object.key = ''
+        @object.store
+      end.to raise_error(ArgumentError)
     end
 
     it "passes quorum parameters and returnbody to the backend" do
-      expect(@backend).to receive(:store_object).with(@object, :returnbody => false, :w => 3, :dw => 2).and_return(true)
-      @object.store(:returnbody => false, :w => 3, :dw => 2)
+      expect(@backend).to receive(:store_object).
+                           with(@object,
+                                returnbody: false,
+                                w: 3,
+                                dw: 2).
+                           and_return(true)
+      @object.store(returnbody: false, w: 3, dw: 2)
     end
 
     it "raises an error if the object is in conflict" do
@@ -393,7 +408,9 @@ describe Riak::RObject do
       object.raw_data = { 'a' => 7 }
       object.content_type = 'inspect/type'
       Riak::Serializers['inspect/type'] = Object.new.tap do |o|
-        def o.load(object); "serialize for inspect"; end
+        def o.load(object)
+          "serialize for inspect"
+        end
       end
 
       expect(object.inspect).to match(/serialize for inspect/)
@@ -412,13 +429,37 @@ describe Riak::RObject do
   end
 
   describe '#attempt_conflict_resolution' do
-    let(:conflicted_robject) { Riak::RObject.new(@bucket, "conflicted") { |r| r.siblings = [ Riak::RContent.new(r), Riak::RContent.new(r)] } }
+    let(:conflicted_robject) do
+      Riak::RObject.new(@bucket, "conflicted") do |r|
+        r.siblings = [ Riak::RContent.new(r), Riak::RContent.new(r)]
+      end
+    end
     let(:resolved_robject) { Riak::RObject.new(@bucket, "resolved") }
     let(:invoked_resolvers) { [] }
-    let(:resolver_1) { lambda { |r| invoked_resolvers << :resolver_1; nil } }
-    let(:resolver_2) { lambda { |r| invoked_resolvers << :resolver_2; :not_an_robject } }
-    let(:resolver_3) { lambda { |r| invoked_resolvers << :resolver_3; r } }
-    let(:resolver_4) { lambda { |r| invoked_resolvers << :resolver_4; resolved_robject } }
+    let(:resolver_1) do
+      lambda do |r|
+        invoked_resolvers << :resolver_1
+        nil
+      end
+    end
+    let(:resolver_2) do
+      lambda do |r|
+        invoked_resolvers << :resolver_2
+        :not_an_robject
+      end
+    end
+    let(:resolver_3) do
+      lambda do |r|
+        invoked_resolvers << :resolver_3
+        r
+      end
+    end
+    let(:resolver_4) do
+      lambda do |r|
+        invoked_resolvers << :resolver_4
+        resolved_robject
+      end
+    end
 
     before(:each) do
       described_class.on_conflict(&resolver_1)

data/spec/riak/search/index_spec.rb

@@ -42,7 +42,7 @@ describe Riak::Search::Index do
       and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, 'not found'))
 
     expect(backend).to receive(:create_search_index).
-      with(index_name, nil, nil)
+      with(index_name, nil, nil, nil)
 
     expect{ subject.create! }.to_not raise_error
   end
@@ -50,9 +50,19 @@ describe Riak::Search::Index do
   it 'raises an error when creating an index that already exists' do
     index_exists_expectation
 
-    expect{ subject.create! }.to raise_error(Riak::SearchError::IndexExistsError)
+    expect{ subject.create! }.
+      to raise_error(Riak::SearchError::IndexExistsError)
   end
 
+    it "spawns a query" do
+      t = "some query term"
+      expect(subject).to receive(:exists?).and_return(true)
+      expect(query = subject.query(t)).to be_a Riak::Search::Query
+      expect(query.term).to eq t
+      expect(query.index).to eq subject
+      expect(query.client).to eq subject.client
+    end
+
   it 'returns data about the index' do
     index_exists_expectation