riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/search_spec.rb

@@ -5,148 +5,26 @@ describe "Search features" do
   describe Riak::Client do
     before :each do
       @client = Riak::Client.new
-      @http = mock(Riak::Client::HTTPBackend)
-      @client.stub!(:http).and_yield(@http)
+      @pb = double(Riak::Client::BeefcakeProtobuffsBackend)
+      allow(@client).to receive(:backend).and_yield(@pb)
     end
 
     describe "searching" do
       it "should search the default index" do
-        @http.should_receive(:search).with(nil, "foo", {}).and_return({})
+        expect(@pb).to receive(:search).with(nil, "foo", {}).and_return({})
         @client.search("foo")
       end
 
       it "should search the default index with additional options" do
-        @http.should_receive(:search).with(nil, 'foo', 'rows' => 30).and_return({})
+        expect(@pb).to receive(:search).with(nil, 'foo', 'rows' => 30).and_return({})
         @client.search("foo", 'rows' => 30)
       end
 
       it "should search the specified index" do
-        @http.should_receive(:search).with('search', 'foo', {}).and_return({})
+        expect(@pb).to receive(:search).with('search', 'foo', {}).and_return({})
         @client.search("search", "foo")
       end
     end
-
-    describe "indexing documents" do
-      it "should update the default index" do
-        doc = {'field' => "value", 'id' => 1}
-        expect_update_body do |body|
-          root = REXML::Document.new(body).root
-          root.name.should == 'add'
-          root.elements.should have(1).item
-          root.elements[1].each_element do |el|
-            case el.attributes['name']
-            when 'field'
-              el.text.should == 'value'
-            when 'id'
-              el.text.should == '1'
-            else
-              fail "Spurious element in #{root.elements[1]}! #{el}"
-            end
-          end
-        end
-        @client.index(doc)
-      end
-
-      it "should update the specified index" do
-        doc = {'field' => "value", 'id' => 1}
-        expect_update_body(nil, "foo") do |body|
-          root = REXML::Document.new(body).root
-          root.name.should == 'add'
-          root.elements.should have(1).item
-          root.elements[1].each_element do |el|
-            case el.attributes['name']
-            when 'field'
-              el.text.should == 'value'
-            when 'id'
-              el.text.should == '1'
-            else
-              fail "Spurious element in #{root.elements[1]}! #{el}"
-            end
-          end
-        end
-        @client.index("foo", doc)
-      end
-
-      it "should raise an error when documents do not contain an id" do
-        @http.stub!(:update_search_index).and_return(true)
-        lambda { @client.index({:field => "value"}) }.should raise_error(ArgumentError)
-        lambda { @client.index({:id => 1, :field => "value"}) }.should_not raise_error(ArgumentError)
-      end
-
-      it "should include multiple documents in the <add> request" do
-        docs = {'field' => "value", 'id' => 1}, {'foo' => "bar", 'id' => 2}
-        expect_update_body do |body|
-          root = REXML::Document.new(body).root
-          root.name.should == 'add'
-          docs = root.elements
-          docs.each do |d|
-            d.name.should == 'doc'
-            d.elements.size.should == 2
-          end
-          docs[1].each_element do |el|
-            case el.attributes['name']
-            when 'field'
-              el.text.should == 'value'
-            when 'id'
-              el.text.should == '1'
-            else
-              fail "Spurious element in #{docs[0]}! #{el}"
-            end
-          end
-          docs[2].each_element do |el|
-            case el.attributes['name']
-            when 'foo'
-              el.text.should == 'bar'
-            when 'id'
-              el.text.should == '2'
-            else
-              fail "Spurious element in #{docs[1]}! #{el}"
-            end
-          end
-        end
-        @client.index(*docs)
-      end
-    end
-
-    describe "removing documents" do
-      it "should remove documents from the default index" do
-        expect_update_body('<delete><id>1</id></delete>')
-        @client.remove({:id => 1})
-      end
-
-      it "should remove documents from the specified index" do
-        expect_update_body('<delete><id>1</id></delete>', 'foo')
-        @client.remove("foo", {:id => 1})
-      end
-
-      it "should raise an error when document specifications don't include an id or query" do
-        @http.stub!(:update_search_index).and_return({:code => 200})
-        lambda { @client.remove({:foo => "bar"}) }.should raise_error(ArgumentError)
-        lambda { @client.remove({:id => 1}) }.should_not raise_error
-      end
-
-      it "should build a Solr <delete> request" do
-        expect_update_body('<delete><id>1</id></delete>')
-        @client.remove(:id => 1)
-        expect_update_body('<delete><query>title:old</query></delete>')
-        @client.remove(:query => "title:old")
-      end
-
-      it "should include multiple specs in the <delete> request" do
-        expect_update_body('<delete><id>1</id><query>title:old</query></delete>')
-        @client.remove({:id => 1}, {:query => "title:old"})
-      end
-    end
-
-    def expect_update_body(body=nil, index=nil)
-      if block_given?
-        @http.should_receive(:update_search_index).with(index, kind_of(String)) do |i, b|
-          yield b
-        end
-      else
-        @http.should_receive(:update_search_index).with(index, body)
-      end
-    end
   end
 
   describe Riak::Bucket do
@@ -165,22 +43,22 @@ describe "Search features" do
 
     it "should detect whether the indexing hook is installed" do
       load_without_index_hook
-      @bucket.is_indexed?.should be_false
+      expect(@bucket.is_indexed?).to be_falsey
 
       load_with_index_hook
-      @bucket.is_indexed?.should be_true
+      expect(@bucket.is_indexed?).to be_truthy
     end
 
     describe "enabling indexing" do
       it "should add the index hook when not present" do
         load_without_index_hook
-        @bucket.should_receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK], "search" => true})
+        expect(@bucket).to receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK], "search" => true})
         @bucket.enable_index!
       end
 
       it "should not modify the precommit when the hook is present" do
         load_with_index_hook
-        @bucket.should_not_receive(:props=)
+        expect(@bucket).not_to receive(:props=)
         @bucket.enable_index!
       end
     end
@@ -188,13 +66,13 @@ describe "Search features" do
     describe "disabling indexing" do
       it "should remove the index hook when present" do
         load_with_index_hook
-        @bucket.should_receive(:props=).with({"precommit" => [], "search" => false})
+        expect(@bucket).to receive(:props=).with({"precommit" => [], "search" => false})
         @bucket.disable_index!
       end
 
       it "should not modify the precommit when the hook is missing" do
         load_without_index_hook
-        @bucket.should_not_receive(:props=)
+        expect(@bucket).not_to receive(:props=)
         @bucket.disable_index!
       end
     end
@@ -209,20 +87,20 @@ describe "Search features" do
     describe "using a search query as inputs" do
       it "should accept a bucket name and query" do
         @mr.search("foo", "bar OR baz")
-        @mr.inputs.should == {:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]}
+        expect(@mr.inputs).to eq({:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
       end
 
       it "should accept a Riak::Bucket and query" do
         @mr.search(Riak::Bucket.new(@client, "foo"), "bar OR baz")
-        @mr.inputs.should == {:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]}
+        expect(@mr.inputs).to eq({:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
       end
 
       it "should emit the Erlang function and arguments" do
         @mr.search("foo", "bar OR baz")
-        @mr.to_json.should include('"inputs":{')
-        @mr.to_json.should include('"module":"riak_search"')
-        @mr.to_json.should include('"function":"mapred_search"')
-        @mr.to_json.should include('"arg":["foo","bar OR baz"]')
+        expect(@mr.to_json).to include('"inputs":{')
+        expect(@mr.to_json).to include('"module":"riak_search"')
+        expect(@mr.to_json).to include('"function":"mapred_search"')
+        expect(@mr.to_json).to include('"arg":["foo","bar OR baz"]')
       end
     end
   end

data/spec/riak/secondary_index_spec.rb

@@ -8,49 +8,49 @@ describe Riak::SecondaryIndex do
 
   describe "initialization" do
     it "should accept a bucket, index name, and scalar" do
-      lambda { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa' }.should_not raise_error
-      lambda { Riak::SecondaryIndex.new @bucket, 'asdf', 12345 }.should_not raise_error
+      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa' }.not_to raise_error
+      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 12345 }.not_to raise_error
     end
 
     it "should accept a bucket, index name, and a range" do
-      lambda { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa'..'zzzz' }.should_not raise_error
-      lambda { Riak::SecondaryIndex.new @bucket, 'asdf', 1..5 }.should_not raise_error
+      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa'..'zzzz' }.not_to raise_error
+      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 1..5 }.not_to raise_error
     end
   end
 
   describe "operation" do
     before(:each) do
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
       @args = [@bucket, 'asdf', 'aaaa'..'zzzz', {}]
       @index = Riak::SecondaryIndex.new *@args
 
-      @backend.should_receive(:get_index).with(*@args).and_return(%w{abcd efgh})
+      expect(@backend).to receive(:get_index).with(*@args).and_return(%w{abcd efgh})
     end
 
     it "should return an array of keys" do
       @results = @index.keys
-      @results.should be_a Array
-      @results.first.should be_a String
+      expect(@results).to be_a Array
+      expect(@results.first).to be_a String
     end
     it "should return an array of values" do
-      @backend.should_receive(:fetch_object).with(@bucket, 'abcd', {}).and_return('abcd')
-      @backend.should_receive(:fetch_object).with(@bucket, 'efgh', {}).and_return('efgh')
+      expect(@backend).to receive(:fetch_object).with(@bucket, 'abcd', {}).and_return('abcd')
+      expect(@backend).to receive(:fetch_object).with(@bucket, 'efgh', {}).and_return('efgh')
 
       @results = @index.values
-      @results.should be_a Array
-      @results.length.should == 2
+      expect(@results).to be_a Array
+      expect(@results.length).to eq(2)
     end
   end
 
   describe "streaming" do
     it "should stream keys into a block" do
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
       @args = [@bucket, 'asdf', 'aaaa'..'zzzz', {stream: true}]
       @index = Riak::SecondaryIndex.new *@args
 
-      @backend.should_receive(:get_index).with(*@args).and_yield('abcd').and_yield('efgh')
+      expect(@backend).to receive(:get_index).with(*@args).and_yield('abcd').and_yield('efgh')
 
       @index.keys {|b| :noop }
     end
@@ -65,10 +65,10 @@ describe Riak::SecondaryIndex do
         'continuation' => 'examplecontinuation'
       }.to_json)
 
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
-      @backend.
-        should_receive(:get_index).
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
+      expect(@backend).
+        to receive(:get_index).
         with(
              @bucket,
              'asdf',
@@ -76,7 +76,7 @@ describe Riak::SecondaryIndex do
              :max_results => @max_results
              ).
         and_return(@expected_collection)
-      @backend.stub(:get_server_version => '1.4.0')
+      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
 
 
       @index = Riak::SecondaryIndex.new(
@@ -87,9 +87,9 @@ describe Riak::SecondaryIndex do
                                         )
 
       @results = @index.keys
-      @results.should be_an Array
-      @results.should == @expected_collection
-      @results.length.should == @max_results
+      expect(@results).to be_an Array
+      expect(@results).to eq(@expected_collection)
+      expect(@results.length).to eq(@max_results)
     end
 
     it "should support continuations" do
@@ -99,10 +99,10 @@ describe Riak::SecondaryIndex do
         'keys' => %w{ffff gggg hhhh}
       }.to_json)
 
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
-      @backend.
-        should_receive(:get_index).
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
+      expect(@backend).
+        to receive(:get_index).
         with(
              @bucket,
              'asdf',
@@ -111,7 +111,7 @@ describe Riak::SecondaryIndex do
              continuation: 'examplecontinuation'
              ).
         and_return(@expected_collection)
-      @backend.stub(:get_server_version => '1.4.0')
+      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
 
 
       @index = Riak::SecondaryIndex.new(
@@ -123,8 +123,8 @@ describe Riak::SecondaryIndex do
                                         )
 
       @results = @index.keys
-      @results.should be_an Array
-      @results.should == @expected_collection
+      expect(@results).to be_an Array
+      expect(@results).to eq(@expected_collection)
     end
 
     it "should support a next_page method" do
@@ -135,10 +135,10 @@ describe Riak::SecondaryIndex do
         'continuation' => 'examplecontinuation'
       }.to_json)
 
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
-      @backend.
-        should_receive(:get_index).
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
+      expect(@backend).
+        to receive(:get_index).
         once.
         with(
              @bucket,
@@ -147,7 +147,7 @@ describe Riak::SecondaryIndex do
              :max_results => @max_results
              ).
         and_return(@expected_collection)
-      @backend.stub(:get_server_version => '1.4.0')
+      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
 
 
       @index = Riak::SecondaryIndex.new(
@@ -158,13 +158,13 @@ describe Riak::SecondaryIndex do
                                         )
 
       @results = @index.keys
-      @results.should == @expected_collection
+      expect(@results).to eq(@expected_collection)
 
       @second_collection = Riak::IndexCollection.new_from_json({
         'keys' => %w{ffff gggg hhhh}
       }.to_json)
-      @backend.
-        should_receive(:get_index).
+      expect(@backend).
+        to receive(:get_index).
         once.
         with(
              @bucket,
@@ -177,7 +177,7 @@ describe Riak::SecondaryIndex do
 
       @second_page = @index.next_page
       @second_results = @second_page.keys
-      @second_results.should == @second_collection
+      expect(@second_results).to eq(@second_collection)
     end
   end
 
@@ -192,10 +192,10 @@ describe Riak::SecondaryIndex do
         }.to_json)
 
 
-      @backend = mock 'Backend'
-      @client.stub!(:backend).and_yield(@backend)
-      @backend.
-        should_receive(:get_index).
+      @backend = double 'Backend'
+      allow(@client).to receive(:backend).and_yield(@backend)
+      expect(@backend).
+        to receive(:get_index).
         with(
              @bucket,
              'asdf',
@@ -203,7 +203,7 @@ describe Riak::SecondaryIndex do
              :return_terms => true
              ).
         and_return(@expected_collection)
-      @backend.stub(:get_server_version => '1.4.0')
+      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
 
 
       @index = Riak::SecondaryIndex.new(
@@ -214,12 +214,12 @@ describe Riak::SecondaryIndex do
                                         )
 
       @results = @index.keys
-      @results.should be_an Array
-      @results.should == @expected_collection
-      @results.with_terms.should == {
+      expect(@results).to be_an Array
+      expect(@results).to eq(@expected_collection)
+      expect(@results.with_terms).to eq({
         'aaaa' => %w{aaaa},
         'bbbb' => %w{bbbb bbbb2}
-      }
+      })
     end
   end
 end

data/spec/riak/serializers_spec.rb

@@ -4,16 +4,16 @@ describe Riak::Serializers do
   shared_examples_for "a serializer" do |type, deserialized, serialized|
     context "for #{type}" do
       it "serializes #{deserialized} to #{serialized}" do
-        described_class.serialize(type, deserialized).should == serialized
+        expect(described_class.serialize(type, deserialized)).to eq(serialized)
       end
 
       it "deserializes #{serialized} to #{deserialized}" do
-        described_class.deserialize(type, serialized).should == deserialized
+        expect(described_class.deserialize(type, serialized)).to eq(deserialized)
       end
 
       it "round trips properly" do
         str = described_class.serialize(type, deserialized)
-        described_class.deserialize(type, str).should == deserialized
+        expect(described_class.deserialize(type, str)).to eq(deserialized)
       end
     end
   end
@@ -28,17 +28,17 @@ describe Riak::Serializers do
 
   %w[ serialize deserialize ].each do |meth|
     describe ".#{meth}" do
-      it 'raises a NotImplementedError when given an unrecognized content type' do
+      it 'raises an IOError when given an unrecognized content type' do
         expect {
           described_class.send(meth, "application/unrecognized", "string")
-        }.to raise_error(NotImplementedError)
+        }.to raise_error(IOError)
       end
     end
   end
 
   describe "plain text serializer" do
     it 'calls #to_s to convert the object to a string' do
-      described_class.serialize("text/plain", :a_string).should == "a_string"
+      expect(described_class.serialize("text/plain", :a_string)).to eq("a_string")
     end
   end
 
@@ -57,11 +57,11 @@ describe Riak::Serializers do
       s = h.to_json(Riak.json_options)
       expect {
         described_class.serialize('application/json', h)
-      }.should_not raise_error
+      }.to_not raise_error
 
       expect {
         described_class.deserialize('application/json', s)
-      }.should_not raise_error
+      }.to_not raise_error
     end
   end
 
@@ -80,7 +80,7 @@ describe Riak::Serializers do
 
     it 'can be registered' do
       described_class['application/custom-type-1'] = custom_serializer
-      described_class['application/custom-type-1'].should be(custom_serializer)
+      expect(described_class['application/custom-type-1']).to be(custom_serializer)
       # fail
     end