riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/beefcake_protobuffs_backend/object_methods_spec.rb

@@ -12,11 +12,11 @@ describe Riak::Client::BeefcakeProtobuffsBackend::ObjectMethods do
 
   describe "loading object data from the response" do
     it "should load the key" do
-      content = stub(:value => '', :vtag => nil, :content_type => nil, :links => nil, :usermeta => nil, :last_mod => nil, :indexes => nil, :charset => nil)
-      pbuf = stub(:vclock => nil, :content => [content], :value => nil, :key => 'akey')
+      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)
-      o.should == @object
-      o.key.should == pbuf.key
+      expect(o).to eq(@object)
+      expect(o.key).to eq(pbuf.key)
     end
   end
 

data/spec/riak/beefcake_protobuffs_backend/protocol_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'riak/client/beefcake/protocol'
+
+describe Riak::Client::BeefcakeProtobuffsBackend::Protocol do
+  let(:socket){ double 'Socket' }
+  subject{ described_class.new socket }
+  let(:codes){ Riak::Client::BeefcakeMessageCodes }
+
+  let(:yz_req){ Riak::Client::BeefcakeProtobuffsBackend::
+    RpbYokozunaSchemaGetReq.new name: 'schema' }
+  let(:ctr_resp){ Riak::Client::BeefcakeProtobuffsBackend::
+    RpbCounterGetResp.new value: rand(2**10) }
+  let(:error_resp){ Riak::Client::BeefcakeProtobuffsBackend::
+    RpbErrorResp.new errcode: rand(2**10), errmsg: 'message' }
+
+  describe 'writing messages' do
+    # I really wanted to call this "send" but Ruby already has that method
+
+    it 'writes messages without a body' do
+      name = :PingReq
+
+      expect(socket).to receive(:write) { |payload|
+        length, code = payload.unpack 'NC'
+        expect(length).to eq 1
+        expect(code).to eq codes.index name
+      }.ordered
+      expect(socket).to receive(:flush).ordered
+
+      subject.write name
+    end
+
+    it 'writes messages with Beefcake::Message instances as bodies' do
+      message = yz_req
+      name = :YokozunaSchemaGetReq
+
+      expect(socket).to receive(:write) { |payload|
+        header = payload[0..4]
+        body = payload[5..-1]
+        length, code = header.unpack 'NC'
+        expect(code).to eq codes.index name
+        expect(length).to eq(body.length + 1)
+        expect(body).to eq message.encode.to_s
+      }.ordered
+      expect(socket).to receive(:flush).ordered
+
+      subject.write name, message
+    end
+
+    it 'raises an error and writes nothing when passed the wrong thing' do
+      expect{ subject.write :YokozunaSchemaGetReq, Object.new }.
+        to raise_error
+    end
+  end
+
+  describe 'receiving messages' do
+    it 'receives messages without a body and returns an array of code-symbol and nil' do
+      name = :PingResp
+      header = [1, codes.index(name)].pack 'NC'
+      expect(socket).to receive(:read).
+        ordered.
+        with(5).
+        and_return(header)
+
+      code, payload = subject.receive
+
+      expect(code).to eq name
+      expect(payload).to eq nil
+    end
+
+    it 'receives messages and returns an array of code-symbol and string' do
+      message = ctr_resp
+      message_str = message.encode.to_s
+      message_len = message_str.length
+      name = :CounterGetResp
+      header = [message_len + 1, codes.index(name)].pack 'NC'
+
+      expect(socket).to receive(:read).
+        ordered.
+        with(5).
+        and_return(header)
+      expect(socket).to receive(:read).
+        ordered.
+        with(message_len).
+        and_return(message_str)
+
+      code, payload = subject.receive
+      
+      expect(code).to eq name
+      expect(payload).to eq message_str
+    end
+  end
+
+  describe 'expecting messages' do
+    describe 'expected message received' do
+      it 'accepts expected messages without a body and returns true' do
+        name = :PingResp
+        header = [1, codes.index(name)].pack 'NC'
+
+        expect(socket).to receive(:read).
+          with(5).
+          and_return(header)
+
+        payload = subject.expect name
+
+        expect(payload).to eq true
+      end
+
+      it 'accepts expected messages and returns a Beefcake::Message instance' do
+        message = ctr_resp
+        message_str = message.encode.to_s
+        message_len = message_str.length
+        name = :CounterGetResp
+        header = [message_len + 1, codes.index(name)].pack 'NC'
+        
+        expect(socket).to receive(:read).
+          ordered.
+          with(5).
+          and_return(header)
+        expect(socket).to receive(:read).
+          ordered.
+          with(message_len).
+          and_return(message_str)
+        
+        payload = subject.expect name, message.class
+
+        expect(payload).to eq message
+        expect(payload.value).to eq message.value
+      end
+
+      it 'accepts messages with an empty body when required to' do
+        name = :PutResp
+        header = [1, codes.index(name)].pack 'NC'
+        decoder_class = double 'RpbPutResp'
+
+        expect(socket).to receive(:read).
+          with(5).
+          and_return(header)
+
+        payload = subject.expect name, decoder_class, empty_body_acceptable: true
+
+        expect(payload).to eq :empty
+      end
+    end
+
+    describe 'unexpected message received' do
+      it 'raises a ProtobuffsUnexpectedResponse error' do
+        message = ctr_resp
+        message_str = message.encode.to_s
+        message_len = message_str.length
+        name = :CounterGetResp
+        header = [message_len + 1, codes.index(name)].pack 'NC'
+        
+        expect(socket).to receive(:read).
+          ordered.
+          with(5).
+          and_return(header)
+        expect(socket).to receive(:read).
+          ordered.
+          with(message_len).
+          and_return(message_str)
+
+        expect{ subject.expect :PingResp }.
+          to raise_error Riak::ProtobuffsUnexpectedResponse
+      end
+    end
+
+    describe 'ErrorResp received' do
+      it 'raises a ProtobuffsErrorResponse error' do
+        message = error_resp
+        message_str = message.encode.to_s
+        message_len = message_str.length
+        name = :ErrorResp
+        header = [message_len + 1, codes.index(name)].pack 'NC'
+        
+        expect(socket).to receive(:read).
+          ordered.
+          with(5).
+          and_return(header)
+        expect(socket).to receive(:read).
+          ordered.
+          with(message_len).
+          and_return(message_str)
+
+        expect{ subject.expect :PingResp }.
+          to raise_error Riak::ProtobuffsErrorResponse
+      end
+    end
+  end
+end

data/spec/riak/beefcake_protobuffs_backend/socket_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require 'riak/client/beefcake/socket'
+
+describe Riak::Client::BeefcakeProtobuffsBackend::BeefcakeSocket do
+  let(:host){ 'host' }
+  let(:pb_port){ 8087 }
+  let(:tcp_socket_instance){ double 'TCPSocket' }
+
+  let(:ssl){ OpenSSL::SSL }
+
+  describe 'without authentication configured' do
+    let(:options){ Hash.new }
+    it 'should start a tcp connection and not start a tls connection' do
+      expect(TCPSocket).to receive(:new).
+        with(host, pb_port).
+        and_return(tcp_socket_instance)
+
+      expect(tcp_socket_instance).to receive(:setsockopt).
+        with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+
+      expect(ssl::SSLSocket).not_to receive(:new)
+
+      described_class.new host, pb_port
+    end
+  end
+
+  describe 'with authentication configured' do
+    let(:user){ 'user' }
+    let(:password){ 'password' }
+    let(:options) do
+      {
+        authentication: { 
+          user: user,
+          password: password
+        } 
+      }
+    end
+    let(:ssl_socket_instance){ double 'SSLSocket' }
+    let(:ssl_peer_cert){ double 'Peer Certificate' }
+    let(:r509_cert){ double 'R509::Cert' }
+    let(:rcv_instance){ double 'R509::Cert::Validator instance' }
+
+    it 'should start a tcp and a tls connection, and send authentication info' do
+      expect(TCPSocket).to receive(:new).
+        with(host, pb_port).
+        and_return(tcp_socket_instance)
+
+      expect(tcp_socket_instance).to receive(:setsockopt).
+        with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+
+      allow(tcp_socket_instance).to receive(:write)
+
+      # StartTls
+      expect(tcp_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 255].pack 'NC')
+
+      expect(ssl::SSLSocket).to receive(:new).
+        with(tcp_socket_instance, kind_of(OpenSSL::SSL::SSLContext)).
+        and_return(ssl_socket_instance)
+
+      expect(ssl_socket_instance).to receive(:connect)
+
+      allow(ssl_socket_instance).to receive(:write)
+
+      expect(ssl_socket_instance).to receive(:peer_cert).
+        and_return(ssl_peer_cert)
+      expect(R509::Cert).to receive(:new).
+        with(cert: ssl_peer_cert).
+        and_return(r509_cert)
+      allow(r509_cert).to receive(:valid?).and_return(true)
+      expect(R509::Cert::Validator).to receive(:new).
+        with(r509_cert).
+        and_return(rcv_instance)
+
+      expect(rcv_instance).to receive(:validate).
+        with(ocsp: false, crl: false, crl_file: nil).
+        and_return(true)
+
+      # AuthResp
+      expect(ssl_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 254].pack 'NC')
+
+      # PingResp
+      expect(ssl_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 2].pack 'NC')
+
+      described_class.new host, pb_port, options
+    end
+
+    it 'should pass pass TLS options through to OpenSSL' do
+      options[:authentication][:ca_file] = 'spec/support/certs/ca.crt'
+      options[:authentication][:key] = 'spec/support/certs/client.key'
+
+      expect(TCPSocket).to receive(:new).
+        with(host, pb_port).
+        and_return(tcp_socket_instance)
+
+      expect(tcp_socket_instance).to receive(:setsockopt).
+        with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+
+      allow(tcp_socket_instance).to receive(:write)
+
+      # StartTls
+      expect(tcp_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 255].pack 'NC')
+
+      expect(ssl::SSLSocket).to receive(:new) do |sock, ctx|
+        expect(sock).to eq tcp_socket_instance
+        expect(ctx).to be_a OpenSSL::SSL::SSLContext
+        expect(ctx.key).to be_a OpenSSL::PKey::PKey
+        expect(ctx.ca_file).to eq 'spec/support/certs/ca.crt'
+        
+        ssl_socket_instance
+      end
+
+      expect(ssl_socket_instance).to receive(:connect)
+
+      allow(ssl_socket_instance).to receive(:write)
+
+      expect(ssl_socket_instance).to receive(:peer_cert).
+        and_return(ssl_peer_cert)
+      expect(R509::Cert).to receive(:new).
+        with(cert: ssl_peer_cert).
+        and_return(r509_cert)
+      allow(r509_cert).to receive(:valid?).and_return(true)
+      expect(R509::Cert::Validator).to receive(:new).
+        with(r509_cert).
+        and_return(rcv_instance)
+
+      expect(rcv_instance).to receive(:validate).
+        with(ocsp: false, crl: false, crl_file: nil).
+        and_return(true)
+
+      # AuthResp
+      expect(ssl_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 254].pack 'NC')
+
+      # PingResp
+      expect(ssl_socket_instance).to receive(:read).
+        with(5).
+        and_return([1, 2].pack 'NC')
+
+      described_class.new host, pb_port, options
+    end
+  end
+end

data/spec/riak/beefcake_protobuffs_backend_spec.rb

@@ -1,72 +1,46 @@
 require 'spec_helper'
 
 describe Riak::Client::BeefcakeProtobuffsBackend do
-  before(:all) { described_class.should be_configured }
-  before(:each) { backend.stub(:get_server_version => "1.2.0") }
+  before(:all) { expect(described_class).to be_configured }
   let(:client) { Riak::Client.new }
   let(:node) { client.nodes.first }
   let(:backend) { Riak::Client::BeefcakeProtobuffsBackend.new(client, node) }
-
-  it "should only write to the socket one time per request" do
-    exp_bucket, exp_keys = 'foo', ['bar']
-    mock_socket = mock("mock TCP socket")
-
-    backend.stub!(:socket).and_return(mock_socket)
-    mock_socket.should_receive(:write).exactly(1).with do |param|
-      len, code = param[0,5].unpack("NC")
-      req = Riak::Client::BeefcakeProtobuffsBackend::RpbListKeysReq.decode(param[5..-1])
-      code == 17 && req.bucket == exp_bucket
-    end
-
-    responses = Array.new(2) do |index|
-      resp = Riak::Client::BeefcakeProtobuffsBackend::RpbListKeysResp.new
-      if index == 0
-        resp.keys = exp_keys
-      else
-        resp.done = true
-      end
-      resp
-    end
-
-    responses.each do |response|
-      encoded_response = response.encode
-      mock_socket.should_receive(:read).exactly(1).with(5).and_return([1 + encoded_response.length, 18].pack("NC"))
-      mock_socket.should_receive(:read).exactly(1).with(encoded_response.length).and_return(encoded_response)
-    end
-
-    backend.list_keys(exp_bucket).should == exp_keys
+  let(:protocol){ double 'protocol' }
+  before(:each) do
+    allow(backend).to receive(:get_server_version).and_return("2.0.0")
+    allow(backend).to receive(:protocol).and_yield(protocol)
   end
 
   context "secondary index" do
     before :each do
-      @socket = mock(:socket).as_null_object
-      TCPSocket.stub(:new => @socket)
+      @socket = double(:socket).as_null_object
+      allow(TCPSocket).to receive(:new).and_return(@socket)
     end
 
     it 'should raise an appropriate error when 2i is not available' do
-      backend.should_receive(:write_protobuff)
-      response_message = Riak::Client::BeefcakeProtobuffsBackend::
-        RpbErrorResp.
-        new(errmsg: '{error,{indexes_not_supported,riak_kv_bitcask_backend}}',
-            errcode: 0).
-        encode
-
-      response_header = [response_message.length + 1, 0].pack('NC')
-
-      @socket.should_receive(:read).with(5).and_return response_header
-      @socket.should_receive(:read).with(response_message.length).and_return response_message
-
-      expect{ backend.get_index 'bucket', 'words', 'asdf' }.to raise_error "Expected success from Riak but received 0. Secondary indexes aren't supported on the riak_kv_bitcask_backend backend."
+      expect(protocol).to receive(:write)
+      expect(protocol).to receive(:expect).
+        and_raise(
+                  Riak::ProtobuffsErrorResponse.
+                  new(Riak::Client::BeefcakeProtobuffsBackend::
+                      RpbErrorResp.
+                      new(errmsg: '{error,{indexes_not_supported,riak_kv_bitcask_backend}}',
+                          errcode: 0)
+                      )
+                  )
+      
+      expect{ backend.get_index 'bucket', 'words', 'asdf' }.to raise_error /Secondary indexes aren't supported/
       # '
     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
+        expect(protocol).to receive(:write) do |msg, req|
+          expect(msg).to eq(:IndexReq)
+          expect(req[:stream]).to eq(true)
         end
-        backend.should_receive(:decode_index_response)
+        expect(protocol).to receive(:expect).
+          and_return(Riak::Client::BeefcakeProtobuffsBackend::RpbIndexResp.new keys: %w{'asdf'}, done: true)
 
         blk = proc{:asdf}
         
@@ -74,7 +48,7 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
       end
 
       it "should send batches of results to the block" do
-        backend.should_receive(:write_protobuff)
+        expect(protocol).to receive(:write)
         
         response_sets = [%w{asdf asdg asdh}, %w{gggg gggh gggi}]
         response_messages = response_sets.map do |s| 
@@ -82,17 +56,11 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
         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)
+        expect(protocol).to receive(:expect).and_return(*response_messages)
 
-        block_body = mock 'block'
-        block_body.should_receive(:check).with(response_sets.first).once
-        block_body.should_receive(:check).with(response_sets.last).once
+        block_body = double 'block'
+        expect(block_body).to receive(:check).with(response_sets.first).once
+        expect(block_body).to receive(:check).with(response_sets.last).once
         
         blk = proc {|m| block_body.check m }
 
@@ -101,44 +69,40 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
     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
+      expect(protocol).to receive(:write) do |msg, req|
+        expect(msg).to eq(:IndexReq)
+        expect(req[:stream]).not_to 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)
+                         )
+      expect(protocol).to receive(:expect).
+        and_return(response_message)
       
       results = backend.get_index 'bucket', 'words', 'asdf'..'hjkl'
-      results.should == %w{asdf asdg asdh}
+      expect(results).to eq(%w{asdf asdg asdh})
     end
 
     it "should not crash out when no keys or terms are returned" do
-      backend.should_receive(:write_protobuff) do |msg, req|
-        msg.should == :IndexReq
-        req[:stream].should_not be
+      expect(protocol).to receive(:write) do |msg, req|
+        expect(msg).to eq(:IndexReq)
+        expect(req[:stream]).not_to be
       end
 
       response_message = Riak::Client::BeefcakeProtobuffsBackend::
-        RpbIndexResp.new().encode
+        RpbIndexResp.new()
 
-      header = [response_message.length + 1, 26].pack 'NC'
-      @socket.
-        should_receive(:read).
-        with(5).
-        and_return(header)
+      expect(protocol).to receive(:expect).and_return(response_message)
 
       results = nil
       fetch = proc do
         results = backend.get_index 'bucket', 'words', 'asdf'
       end
 
-      fetch.should_not raise_error
-      results.should == []
+      expect(fetch).not_to raise_error
+      expect(results).to eq([])
     end
   end
 
@@ -146,20 +110,24 @@ describe Riak::Client::BeefcakeProtobuffsBackend 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
-      socket = stub(:socket).as_null_object
-      socket.stub(:read).and_return(stub(:socket_header, :unpack => [2, 24]), stub(:socket_message), stub(:socket_header_2, :unpack => [0, 1]))
-      message = stub(:message, :phase => 1, :response => [{}].to_json)
-      message.stub(:done).and_return(false, true)
-      Riak::Client::BeefcakeProtobuffsBackend::RpbMapRedResp.stub(:decode => message)
-      TCPSocket.stub(:new => socket)
-      backend.send(:reset_socket)
-
-      backend.mapred(mapred).should == [{}]
+      expect(protocol).to receive(:write)
+
+      message = double(:message, :phase => 1, :response => [{}].to_json)
+      allow(message).to receive(:done).and_return(false, true)
+
+      expect(protocol).to receive(:expect).
+        twice.
+        and_return(message)
+
+      expect(backend.mapred(mapred)).to eq([{}])
     end
   end
 
   context "preventing stale writes" do
-    before { backend.stub(:decode_response => nil, :get_server_version => "1.0.3") }
+    before do
+      allow(backend).to receive(:decode_response).and_return(nil)
+      allow(backend).to receive(:get_server_version).and_return("1.0.3")
+    end
 
     let(:robject) do
       Riak::RObject.new(client['stale'], 'prevent').tap do |obj|
@@ -170,31 +138,25 @@ describe Riak::Client::BeefcakeProtobuffsBackend do
     end
 
     it "should set the if_none_match field when the object is new" do
-      backend.should_receive(:write_protobuff) do |msg, req|
-        msg.should == :PutReq
-        req.if_none_match.should be_true
+      expect(protocol).to receive(:write) do |msg, req|
+        expect(msg).to eq(:PutReq)
+        expect(req.if_none_match).to be_truthy
       end
+      expect(protocol).to receive(:expect).
+        and_return(:empty)
+
       backend.store_object(robject)
     end
 
     it "should set the if_not_modified field when the object has a vclock" do
       robject.vclock = Base64.encode64("foo")
-      backend.should_receive(:write_protobuff) do |msg, req|
-        msg.should == :PutReq
-        req.if_not_modified.should be_true
+      expect(protocol).to receive(:write) do |msg, req|
+        expect(msg).to eq(:PutReq)
+        expect(req.if_not_modified).to be_truthy
       end
+      expect(protocol).to receive(:expect).
+        and_return(:empty)
       backend.store_object(robject)
     end
-
-    context "when conditional requests are not supported" do
-      before { backend.stub(:get_server_version => "0.14.2") }
-      let(:other) { robject.dup.tap {|o| o.vclock = 'bar' } }
-
-      it "should fetch the original object and raise if not equivalent" do
-        robject.vclock = Base64.encode64("foo")
-        backend.should_receive(:fetch_object).and_return(other)
-        expect { backend.store_object(robject) }.to raise_error(Riak::FailedRequest)
-      end
-    end
   end
 end