riak-client 2.5.0 → 2.6.0

data/spec/riak/beefcake_protobuffs_backend/crdt_operator_spec.rb

@@ -1,244 +0,0 @@
-require 'spec_helper'
-Riak::Client::BeefcakeProtobuffsBackend.configured?
-
-describe Riak::Client::BeefcakeProtobuffsBackend::CrdtOperator do
-
-  let(:backend_class){ Riak::Client::BeefcakeProtobuffsBackend }
-  let(:backend){ double 'beefcake protobuffs backend' }
-  subject { described_class.new backend }
-
-
-  describe 'operating on a counter' do
-    let(:increment){ 5 }
-    let(:operation) do
-      Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :counter
-        op.value = increment
-      end
-    end
-
-    it 'serializes a counter operation into protobuffs' do
-      result = subject.serialize operation
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.counter_op).to be_a backend_class::CounterOp
-      expect(result.counter_op.increment).to eq increment
-    end
-
-    it 'serializes multiple counter operations into protobuffs' do
-      result = subject.serialize [operation, operation]
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.counter_op).to be_a backend_class::CounterOp
-      expect(result.counter_op.increment).to eq (increment * 2)
-    end
-  end
-
-  describe 'operating on a set' do
-    let(:added_element){ 'added_element' }
-    let(:removed_element){ 'removed_element' }
-    let(:operation) do
-      Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :set
-        op.value = {
-          add: [added_element],
-          remove: [removed_element]
-        }
-      end
-    end
-
-    it 'serializes a set operation into protobuffs' do
-      result = subject.serialize operation
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.set_op).to be_a backend_class::SetOp
-      expect(result.set_op.adds).to eq [added_element]
-      expect(result.set_op.removes).to eq [removed_element]
-    end
-  end
-
-  describe 'operating on a hyper_log_log' do
-    let(:added_element){ 'added_element' }
-    let(:operation) do
-      Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :hll
-        op.value = {
-          add: [added_element]
-        }
-      end
-    end
-
-    it 'serializes a hyper_log_log operation into protobuffs' do
-      result = subject.serialize operation
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.hll_op).to be_a backend_class::HllOp
-      expect(result.hll_op.adds).to eq [added_element]
-    end
-  end
-
-  describe 'operating on a map' do
-    it 'serializes inner counter operations' do
-      counter_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_counter'
-        op.type = :counter
-        op.value = 12345
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = counter_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.counter_op).to be_a backend_class::CounterOp
-      expect(map_update.counter_op.increment).to eq 12345
-    end
-
-    it 'serializes inner flag operations' do
-      flag_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_flag'
-        op.type = :flag
-        op.value = true
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = flag_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.flag_op).to eq backend_class::MapUpdate::FlagOp::ENABLE
-
-      flag_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_flag'
-        op.type = :flag
-        op.value = false
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = flag_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.flag_op).to eq backend_class::MapUpdate::FlagOp::DISABLE
-    end
-
-    it 'serializes inner register operations' do
-      register_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_register'
-        op.type = :register
-        op.value = 'hello'
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = register_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.register_op).to eq 'hello'
-
-      delete_op = Riak::Crdt::Operation::Delete.new.tap do |op|
-        op.name = 'inner_register'
-        op.type = :register
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = delete_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{ result.encode }.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_delete = result.map_op.removes.first
-      expect(map_delete).to be_a backend_class::MapField
-      expect(map_delete.name).to eq 'inner_register'
-      expect(map_delete.type).to eq backend_class::MapField::MapFieldType::REGISTER
-    end
-
-    it 'serializes inner set operations' do
-      set_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_set'
-        op.type = :set
-        op.value = {add: 'added_member'}
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = set_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.set_op.adds).to eq 'added_member'
-    end
-
-    it 'serializes inner map operations' do
-      register_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_inner_register'
-        op.type = :register
-        op.value = 'inner_register_value'
-      end
-      inner_map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.name = 'inner_map'
-        op.type = :map
-        op.value = register_op
-      end
-      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
-        op.type = :map
-        op.value = inner_map_op
-      end
-
-      result = subject.serialize map_op
-
-      expect{result.encode}.to_not raise_error
-
-      expect(result).to be_a backend_class::DtOp
-      expect(result.map_op).to be_a backend_class::MapOp
-      map_update = result.map_op.updates.first
-      expect(map_update).to be_a backend_class::MapUpdate
-      expect(map_update.map_op).to be_a backend_class::MapOp
-      expect(map_update.map_op.updates.first.register_op).to eq 'inner_register_value'
-    end
-  end
-end

data/spec/riak/beefcake_protobuffs_backend/object_methods_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-require 'riak/client/beefcake/object_methods'
-require 'riak/client/beefcake/messages'
-
-describe Riak::Client::BeefcakeProtobuffsBackend::ObjectMethods do
-  before :each do
-    @client = Riak::Client.new
-    @backend = Riak::Client::BeefcakeProtobuffsBackend.new(@client, @client.node)
-    @bucket = Riak::Bucket.new(@client, "bucket")
-    @object = Riak::RObject.new(@bucket, "bar")
-    @content = double(
-      :value => '',
-      :vtag => nil,
-      :content_type => nil,
-      :content_encoding => nil,
-      :links => nil,
-      :usermeta => nil,
-      :last_mod => nil,
-      :last_mod_usecs => nil,
-      :indexes => nil,
-      :charset => nil
-    )
-  end
-
-  describe "loading object data from the response" do
-    it "loads the key" do
-      pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
-      o = @backend.load_object(pbuf, @object)
-      expect(o).to eq(@object)
-      expect(o.key).to eq(pbuf.key)
-    end
-
-    describe "last_modified" do
-      before :each do
-        allow(@content).to receive(:last_mod) { 1271442363 }
-      end
-
-      it "is set to time of last_mod with microseconds from last_mod_usecs" do
-        allow(@content).to receive(:last_mod_usecs) { 105696 }
-        pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
-        o = @backend.load_object(pbuf, @object)
-        expect(o.last_modified).to eq(Time.at(1271442363, 105696))
-      end
-
-      it "is set to time of last_mod without microseconds if last_mod_usecs is missing" do
-        pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
-        o = @backend.load_object(pbuf, @object)
-        expect(o.last_modified).to eq(Time.at(1271442363, 0))
-      end
-    end
-  end
-
-end

data/spec/riak/beefcake_protobuffs_backend/protocol_spec.rb

@@ -1,189 +0,0 @@
-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