riak-client 1.2.0 → 1.4.0

data/spec/riak/beefcake_protobuffs_backend_spec.rb

@@ -37,6 +37,90 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
     backend.list_keys(exp_bucket).should == exp_keys
   end
 
+  context "secondary index" do
+    before :each do
+      @socket = mock(:socket).as_null_object
+      TCPSocket.stub(:new => @socket)
+    end
+    context 'when streaming' do
+      it "should stream when a block is given" do 
+        backend.should_receive(:write_protobuff) do |msg, req|
+          msg.should == :IndexReq
+          req[:stream].should == true
+        end
+        backend.should_receive(:decode_index_response)
+
+        blk = proc{:asdf}
+        
+        backend.get_index('bucket', 'words', 'asdf'..'hjkl', &blk)
+      end
+
+      it "should send batches of results to the block" do
+        backend.should_receive(:write_protobuff)
+        
+        response_sets = [%w{asdf asdg asdh}, %w{gggg gggh gggi}]
+        response_messages = response_sets.map do |s| 
+          Riak::Client::BeefcakeProtobuffsBackend::RpbIndexResp.new keys: s
+        end
+        response_messages.last.done = true
+
+        response_chunks = response_messages.map do |m|
+          encoded = m.encode
+          header = [encoded.length + 1, 26].pack 'NC'
+          [header, encoded]
+        end.flatten
+
+        @socket.should_receive(:read).and_return(*response_chunks)
+
+        block_body = mock 'block'
+        block_body.should_receive(:check).with(response_sets.first).once
+        block_body.should_receive(:check).with(response_sets.last).once
+        
+        blk = proc {|m| block_body.check m }
+
+        backend.get_index 'bucket', 'words', 'asdf'..'hjkl', &blk
+      end
+    end
+
+    it "should return a full batch of results when not streaming" do
+      backend.should_receive(:write_protobuff) do |msg, req|
+        msg.should == :IndexReq
+        req[:stream].should_not be
+      end
+
+      response_message = Riak::Client::BeefcakeProtobuffsBackend::
+        RpbIndexResp.new(
+                         keys: %w{asdf asdg asdh}
+                         ).encode
+      header = [response_message.length + 1, 26].pack 'NC'
+      @socket.should_receive(:read).and_return(header, response_message)
+      
+      results = backend.get_index 'bucket', 'words', 'asdf'..'hjkl'
+      results.should == %w{asdf asdg asdh}
+    end
+
+    it "should not crash out when no keys or terms are released" do
+      backend.should_receive(:write_protobuff) do |msg, req|
+        msg.should == :IndexReq
+        req[:stream].should_not be
+      end
+
+      response_message = Riak::Client::BeefcakeProtobuffsBackend::
+        RpbIndexResp.new().encode
+      
+      header = [response_message.length + 1, 26].pack 'NC'
+      @socket.should_receive(:read).and_return(header, response_message)
+
+      results = nil
+      fetch = proc do
+        results = backend.get_index 'bucket', 'words', 'asdf'
+      end
+
+      fetch.should_not raise_error
+      results.should == []
+    end
+  end
+
   context "#mapred" do
     let(:mapred) { Riak::MapReduce.new(client).add('test').map("function(){}").map("function(){}") }
 

data/spec/riak/bucket_spec.rb

@@ -16,6 +16,7 @@ describe Riak::Bucket do
       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(@client, '') }.to raise_error(ArgumentError)
     end
 
     it "should set the client and name attributes" do
@@ -27,12 +28,12 @@ describe Riak::Bucket do
 
   describe "accessing keys" do
     it "should list the keys" do
-      @backend.should_receive(:list_keys).with(@bucket).and_return(["bar"])
+      @backend.should_receive(:list_keys).with(@bucket, {}).and_return(["bar"])
       @bucket.keys.should == ["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"])
+      @backend.should_receive(:list_keys).with(@bucket, {}).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
       all_keys = []
       @bucket.keys do |list|
         all_keys.concat(list)
@@ -41,7 +42,7 @@ describe Riak::Bucket do
     end
 
     it "should not cache the list of keys" do
-      @backend.should_receive(:list_keys).with(@bucket).twice.and_return(["bar"])
+      @backend.should_receive(:list_keys).with(@bucket, {}).twice.and_return(["bar"])
       2.times { @bucket.keys.should == ['bar'] }
     end
 
@@ -52,6 +53,24 @@ describe Riak::Bucket do
       @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})
+
+      keys = @bucket.keys timeout: 1234
+
+      keys.should == %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')
+      
+      new_counter = @bucket.counter 'asdf'
+
+      new_counter.should == 'example counter'
+    end
   end
 
   describe "setting the bucket properties" do
@@ -104,6 +123,12 @@ describe Riak::Bucket do
       @backend.should_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
+      ## 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)
+    end
   end
 
   describe "creating a new blank object" do
@@ -141,10 +166,35 @@ describe Riak::Bucket do
     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)
+
+      @results = @bucket.get_many %w{key1 key2}
+
+      @results['key1'].should == @object1
+      @results['key2'].should == @object2
+    end
+  end
+
   describe "querying an index" do
     it "should list the matching keys" do
-      @backend.should_receive(:get_index).with(@bucket, "test_bin", "testing").and_return(["bar"])
-      @bucket.get_index("test_bin", "testing").should == ["bar"]
+      @backend.
+        should_receive(:get_index).
+        with(@bucket, "test_bin", "testing", {return_terms: true}).
+        and_return(Riak::IndexCollection.new_from_json({
+                     'results' => [
+                       {'testing' => 'asdf'},
+                       {'testing' => 'hjkl'}]
+                   }.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}}
     end
   end
 

data/spec/riak/client_spec.rb

@@ -196,6 +196,29 @@ describe Riak::Client do
     end
   end
 
+  describe "retrieving many values" 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'))
+      @pairs = [
+        [@bucket, 'value1'],
+        [@bucket, 'value2']
+      ]
+    end
+
+    it 'should accept an array of bucket and key pairs' do
+      lambda{ @client.get_many(@pairs) }.should_not 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)
+    end
+  end
+
   describe "retrieving a bucket" do
     before :each do
       @client = Riak::Client.new
@@ -218,6 +241,10 @@ describe Riak::Client do
       @client.bucket("baz").should == @bucket
       @client.bucket("baz").should == @bucket
     end
+
+    it "should reject buckets with zero-length names" do
+      expect { @client.bucket('') }.to raise_error(ArgumentError)
+    end
   end
 
   describe "listing buckets" do
@@ -244,6 +271,13 @@ describe Riak::Client do
       @client.should_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})
+
+      buckets = @client.buckets timeout: 1234
+      buckets.should have(2).items
+    end
   end
 
   describe "Luwak (large-files) support" do

data/spec/riak/counter_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Riak::Counter do
+  describe "initialization" do
+    before :each do
+      @bucket = Riak::Bucket.allocate
+      @key = 'key'
+      @bucket.stub allow_mult: true
+      @bucket.stub(client: mock('client'))
+      @bucket.stub('is_a?' => true)
+    end
+
+    it "should set the bucket and key" do
+      ctr = Riak::Counter.new @bucket, @key
+      ctr.bucket.should == @bucket
+      ctr.key.should == @key
+    end
+
+    it "should require allow_mult" do
+      @bad_bucket = Riak::Bucket.allocate
+      @bad_bucket.stub allow_mult: false
+      @bad_bucket.stub(client: mock('client'))
+
+      expect{ctr = Riak::Counter.new @bad_bucket, @key}.to raise_error(ArgumentError)
+      
+    end
+  end
+  
+  describe "incrementing and decrementing" do
+    before :each do
+      @backend = mock 'backend'
+
+      @client = mock 'client'
+      @client.stub(:backend).and_yield @backend
+
+      @bucket = Riak::Bucket.allocate
+      @bucket.stub allow_mult: true
+      @bucket.stub client: @client
+
+      @key = 'key'
+
+      @ctr = Riak::Counter.new @bucket, @key
+
+      @increment_expectation = proc{|n| @backend.should_receive(:post_counter).with(@bucket, @key, n, {})}
+    end
+
+    it "should increment by 1 by default" do
+      @increment_expectation[1]
+      @ctr.increment
+    end
+
+    it "should support incrementing by positive numbers" do
+      @increment_expectation[15]
+      @ctr.increment 15
+    end
+
+    it "should support incrementing by negative numbers" do
+      @increment_expectation[-12]
+      @ctr.increment -12
+    end
+
+    it "should decrement by 1 by default" do
+      @increment_expectation[-1]
+      @ctr.decrement
+    end
+
+    it "should support decrementing by positive numbers" do
+      @increment_expectation[-30]
+      @ctr.decrement 30
+    end
+
+    it "should support decrementing by negative numbers" do
+      @increment_expectation[41]
+      @ctr.decrement -41
+    end
+
+    it "should forbid incrementing by non-integers" do
+      [1.1, nil, :'1', '1', 2.0/2, [1]].each do |candidate|
+        expect do
+          @ctr.increment candidate
+          raise candidate.to_s
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "failure modes" do
+    before :each do
+      @nodes = 10.times.map do |n|
+        {pb_port: "100#{n}7"}
+      end
+
+      @fake_pool = mock 'pool'
+      @backend = mock 'backend'
+        
+      @client = Riak::Client.new nodes: @nodes, protocol: 'pbc'
+      @client.instance_variable_set :@protobuffs_pool, @fake_pool
+
+      @fake_pool.stub(:take).and_yield(@backend)
+
+      @bucket = Riak::Bucket.allocate
+      @bucket.stub allow_mult: true
+      @bucket.stub client: @client
+
+      @key = 'key'
+
+      @expect_post = @backend.should_receive(:post_counter).with(@bucket, @key, 1, {})
+
+      @ctr = Riak::Counter.new @bucket, @key
+    end
+
+    it "should not retry on timeout" do
+      @expect_post.once.and_raise('timeout')
+      expect(proc { @ctr.increment }).to raise_error
+    end
+    
+    it "should not retry on quorum failure" do
+      @expect_post.once.and_raise('quorum not satisfied')
+      expect(proc { @ctr.increment }).to raise_error
+    end
+  end
+end

data/spec/riak/index_collection_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Riak::IndexCollection do
+  describe "json initialization" do
+    it "should accept a list of keys" do
+      @input = {
+        'keys' => %w{first second third}
+      }.to_json
+      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
+      %w{first second third}.should == @coll
+    end
+    it "should accept a list of keys and a continuation" do
+      @input = {
+        'keys' => %w{first second third},
+        'continuation' => 'examplecontinuation'
+      }.to_json
+      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
+      %w{first second third}.should == @coll
+      @coll.continuation.should == 'examplecontinuation'
+    end
+    it "should accept a list of results hashes" do
+      @input = {
+        'results' => [
+          {'first' => 'first'},
+          {'second' => 'second'},
+          {'second' => 'other'}
+        ]
+      }.to_json
+
+      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
+      %w{first second other}.should == @coll
+      {'first' => %w{first}, 'second' => %w{second other}}.should == @coll.with_terms
+    end
+    it "should accept a list of results hashes and a continuation" do
+      @input = {
+        'results' => [
+          {'first' => 'first'},
+          {'second' => 'second'},
+          {'second' => 'other'}
+        ],
+        'continuation' => 'examplecontinuation'
+      }.to_json
+
+      lambda { @coll = Riak::IndexCollection.new_from_json @input }.should_not raise_error
+      %w{first second other}.should == @coll
+      @coll.continuation.should == 'examplecontinuation'
+      {'first' => %w{first}, 'second' => %w{second other}}.should == @coll.with_terms
+    end
+  end
+end

data/spec/riak/list_buckets_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Riak::ListBuckets do
+  before :each do
+    @client = Riak::Client.new protocol: 'pbc'
+    @backend = mock 'backend'
+    @fake_pool = mock 'connection pool'
+    @fake_pool.stub(:take).and_yield(@backend)
+
+    @expect_list = @backend.should_receive(:list_buckets)
+
+    @client.instance_variable_set :@protobuffs_pool, @fake_pool
+  end
+
+  describe "non-streaming" do
+    it 'should call the backend without a block' do
+      @expect_list.with({}).and_return(%w{a b c d})
+
+      @client.list_buckets
+    end
+  end
+
+  describe "streaming" do
+    it 'should call the backend with a block' do
+      @expect_list.
+        and_yield(%w{abc abd abe}).
+        and_yield(%w{bbb ccc ddd})
+
+      @yielded = []
+
+      @client.list_buckets do |bucket|
+        @yielded << bucket
+      end
+
+      @yielded.each do |b|
+        b.should be_a Riak::Bucket
+      end
+      @yielded.map(&:name).should == %w{abc abd abe bbb ccc ddd}
+    end
+  end
+end