riak-client 2.5.0 → 2.6.0

data/spec/riak/crdt/set_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::Set do
-  let(:bucket) do
-    double('bucket').tap do |b|
-      allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).with(Riak::Bucket).and_return(true)
-      allow(b).to receive(:is_a?).with(Riak::BucketTyped::Bucket).and_return(false)
-    end
-  end
-
-  it 'initializes with bucket, key, and optional bucket-type' do
-    expect{described_class.new bucket, 'key', 'optional bucket type'}.
-      to_not raise_error
-  end
-
-  subject{ described_class.new bucket, 'key' }
-
-  describe 'with a client' do
-    let(:response){ double 'response', key: nil }
-    let(:operator){ double 'operator' }
-    let(:loader){ double 'loader', get_loader_for_value: nil }
-    let(:backend){ double 'backend' }
-    let(:client){ double 'client' }
-
-    before(:each) do
-      allow(bucket).to receive(:client).and_return(client)
-      allow(client).to receive(:backend).and_yield(backend)
-      allow(backend).to receive(:crdt_operator).and_return(operator)
-      allow(backend).to receive(:crdt_loader).and_return(loader)
-    end
-
-    include_examples 'Set CRDT'
-
-    it 'batches properly' do
-      expect(operator).
-        to receive(:operate) { |bucket, key, type, operations|
-
-        expect(bucket).to eq bucket
-        expect(key).to eq 'key'
-        expect(type).to eq subject.bucket_type
-
-        expect(operations).to be_a Riak::Crdt::Operation::Update
-        expect(operations.value).to eq({
-                                         add: %w{alpha bravo},
-                                         remove: %w{foxtrot}
-                                       })
-      }.
-        and_return(response)
-
-      subject.instance_variable_set :@context, 'placeholder'
-
-      subject.batch do |s|
-        s.add 'alpha'
-        s.add 'bravo'
-        s.remove 'foxtrot'
-      end
-    end
-  end
-end

data/spec/riak/crdt/shared_examples.rb

@@ -1,88 +0,0 @@
-shared_examples_for "Map CRDT" do
-  let(:typed_collection){ Riak::Crdt::TypedCollection }
-
-  it 'contains counters' do
-    expect(subject).to respond_to(:counters)
-    expect(subject.counters).to be_an_instance_of typed_collection
-  end
-
-  it 'contains flags' do
-    expect(subject).to respond_to(:flags)
-    expect(subject.counters).to be_an_instance_of typed_collection
-  end
-
-  it 'contains maps' do
-    expect(subject).to respond_to(:maps)
-    expect(subject.counters).to be_an_instance_of typed_collection
-  end
-
-  it 'contains registers' do
-    expect(subject).to respond_to(:registers)
-    expect(subject.counters).to be_an_instance_of typed_collection
-  end
-
-  it 'contains sets' do
-    expect(subject).to respond_to(:sets)
-    expect(subject.counters).to be_an_instance_of typed_collection
-  end
-
-  it 'accepts operations' do
-    expect(subject).to respond_to(:operate)
-  end
-end
-
-shared_examples_for "Counter CRDT" do
-  it 'has a value' do
-    expect(subject).to respond_to :value
-  end
-
-  it 'has an increment method' do
-    expect(subject).to respond_to :increment
-  end
-
-  it 'has a decrement method' do
-    expect(subject).to respond_to :decrement
-  end
-
-  it 'has a batch method' do
-    expect(subject).to respond_to :batch
-  end
-end
-
-shared_examples_for 'Set CRDT' do
-  it 'has a value' do
-    expect(subject).to respond_to :value
-    expect(subject).to respond_to :members
-    expect(subject).to respond_to :to_a
-  end
-
-  it 'has an include? method' do
-    expect(subject).to respond_to :include?
-  end
-
-  it 'has an empty? method' do
-    expect(subject).to respond_to :empty?
-  end
-
-  it 'has an add method' do
-    expect(subject).to respond_to :add
-  end
-
-  it 'has a remove method' do
-    expect(subject).to respond_to :remove
-  end
-end
-
-shared_examples_for 'HyperLogLog CRDT' do
-  it 'has a value' do
-    expect(subject).to respond_to :value
-  end
-
-  it 'has a cardinality' do
-    expect(subject).to respond_to :cardinality
-  end
-
-  it 'has an add method' do
-    expect(subject).to respond_to :add
-  end
-end

data/spec/riak/crdt/typed_collection_spec.rb

@@ -1,225 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Crdt::TypedCollection do
-  let(:parent){ double 'parent' }
-  let(:operation){ double 'operation' }
-
-  describe 'initialization' do
-    it "accepts a type, parent, and hash of values" do
-      expect{ described_class.new Riak::Crdt::Counter, parent, {} }.to_not raise_error
-    end
-  end
-
-  describe 'containing' do
-    describe 'registers' do
-      let(:register_class){ Riak::Crdt::InnerRegister }
-      subject do
-        described_class.new register_class, parent, existing: 'existing'
-      end
-
-      it 'exposes them as frozen strings that are really Registers' do
-        expect(subject[:existing]).to eq 'existing'
-        expect(subject['existing']).to eq 'existing'
-        expect(subject[:existing]).to be_an_instance_of register_class
-        expect(subject['existing'].frozen?).to be
-        expect{subject['existing'].gsub!('e', 'a')}.to raise_error
-      end
-
-      describe 'creating and updating' do
-
-        let(:new_value){ 'the new value' }
-
-        it 'asks the register class for an operation' do
-          expect(register_class).to receive(:update).
-            with(new_value).
-            and_return(operation)
-
-          expect(operation).
-            to receive(:name=).
-            with('existing')
-
-          expect(parent).
-            to receive(:operate).
-            with(operation)
-
-          subject['existing'] = new_value
-        end
-      end
-
-      describe 'removing' do
-
-        it 'asks the register class for a remove operation' do
-          expect(register_class).
-            to receive(:delete).
-            and_return(operation)
-
-          expect(operation).
-            to receive(:name=).
-            with('existing')
-
-          expect(parent).
-            to receive(:operate).
-            with(operation)
-
-          subject.delete 'existing'
-        end
-      end
-    end
-    describe 'flags' do
-      let(:flag_class){ Riak::Crdt::InnerFlag }
-      subject do
-        described_class.new flag_class, parent, truthy: true, falsey: false
-      end
-
-      it 'exposes them as booleans' do
-        expect(subject[:truthy]).to eq true
-        expect(subject['falsey']).to eq false
-      end
-
-      it 'updates them' do
-        expect(flag_class).
-          to receive(:update).
-          with(true).
-          and_return(operation)
-
-        expect(operation).
-          to receive(:name=).
-          with('become_truthy')
-
-        expect(parent).
-          to receive(:operate).
-          with(operation)
-
-        subject['become_truthy'] = true
-      end
-
-      it 'deletes them' do
-        expect(flag_class).
-          to receive(:delete).
-          and_return(operation)
-
-        expect(operation).
-          to receive(:name=).
-          with('become_deleted')
-
-        expect(parent).
-          to receive(:operate).
-          with(operation)
-
-        subject.delete 'become_deleted'
-      end
-    end
-    describe 'counters' do
-      let(:counter_class){ Riak::Crdt::InnerCounter }
-
-      subject{ described_class.new counter_class, parent, zero: 0, one: 1 }
-
-      it 'exposes existing ones as Counter instances' do
-        expect(subject['zero']).to be_an_instance_of counter_class
-        expect(subject['zero'].to_i).to eq 0
-
-        expect(subject['one'].to_i).to eq 1
-      end
-
-      it 'exposes new ones as Counter instances' do
-        expect(subject['new_zero']).to be_an_instance_of counter_class
-        expect(subject['new_zero'].to_i).to eq 0
-      end
-
-      it 'allows incrementing and decrementing' do
-        counter_name = 'counter'
-
-        expect(parent).to receive(:operate) do |op|
-          expect(op.name).to eq counter_name
-          expect(op.type).to eq :counter
-          expect(op.value).to eq 1
-        end
-        subject[counter_name].increment
-
-        expect(parent).to receive(:operate) do |op|
-          expect(op.name).to eq counter_name
-          expect(op.type).to eq :counter
-          expect(op.value).to eq -5
-        end
-
-        subject[counter_name].decrement 5
-      end
-    end
-    describe 'sets' do
-      let(:set_class){ Riak::Crdt::InnerSet }
-
-      subject{ described_class.new set_class, parent, brewers: %w{aeropress clever v60}}
-
-      it 'exposes existing ones as Set instances' do
-        expect(subject['brewers']).to be_an_instance_of set_class
-        expect(subject['brewers']).to include 'aeropress'
-      end
-
-      it 'exposes new ones as empty Set instances' do
-        expect(subject['filters']).to be_an_instance_of set_class
-        expect(subject['filters']).to be_empty
-      end
-
-      it 'allows adding and removing' do
-        set_name = 'brewers'
-
-        expect(parent).to receive(:operate) do |op|
-          expect(op.name).to eq set_name
-          expect(op.type).to eq :set
-          expect(op.value).to eq add: 'frenchpress'
-        end
-        subject[set_name].add 'frenchpress'
-
-        expect(parent).to receive(:operate) do |op|
-          expect(op.name).to eq set_name
-          expect(op.type).to eq :set
-          expect(op.value).to eq remove: 'aeropress'
-        end
-        allow(parent).to receive(:context?).and_return(true)
-
-        subject[set_name].remove 'aeropress'
-      end
-    end
-
-    describe 'maps' do
-      let(:map_class){ Riak::Crdt::InnerMap }
-
-      let(:contents) do {a: {
-            counters: {},
-            flags: {},
-            maps: {},
-            registers: {'hello' => 'world'},
-            sets: {}
-          }}
-        end
-
-      let(:inner_map_name){ 'inner map' }
-
-      subject do
-        described_class.new map_class, parent, contents
-      end
-
-      it 'exposes existing ones as populated Map instances' do
-        expect(subject['a']).to be_an_instance_of map_class
-        expect(subject['a'].registers['hello']).to eq 'world'
-      end
-
-      it 'exposes new ones as empty Map instances' do
-        expect(subject['b']).to be_an_instance_of map_class
-        expect(subject['b'].registers['hello']).to be_nil
-      end
-
-      it 'cascades operations to a parent map' do
-        expect(operation).
-          to receive(:name=).
-          with(inner_map_name)
-
-        expect(parent).
-          to receive(:operate).
-          with(operation)
-
-        subject.operate inner_map_name, operation
-      end
-    end
-  end
-end

data/spec/riak/escape_spec.rb

@@ -1,72 +0,0 @@
-
-require 'spec_helper'
-
-describe Riak::Util::Escape do
-  before :each do
-    @object = Object.new
-    @object.extend(Riak::Util::Escape)
-  end
-
-  it "uses URI by default for escaping" do
-    expect(Riak.escaper).to eq(URI)
-  end
-
-  context "when using CGI for escaping" do
-    before { @oldesc, Riak.escaper = Riak.escaper, CGI }
-    after { Riak.escaper = @oldesc }
-
-    it "escapes standard non-safe characters" do
-      expect(@object.escape("some string")).to eq("some%20string")
-      expect(@object.escape("another^one")).to eq("another%5Eone")
-      expect(@object.escape("bracket[one")).to eq("bracket%5Bone")
-    end
-
-    it "escapes slashes" do
-      expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
-    end
-
-    it "converts the bucket or key to a string before escaping" do
-      expect(@object.escape(125)).to eq('125')
-    end
-
-    it "unescapes escaped strings" do
-      expect(@object.unescape("some%20string")).to eq("some string")
-      expect(@object.unescape("another%5Eone")).to eq("another^one")
-      expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")
-      expect(@object.unescape("some%2Finner%2Fpath")).to eq("some/inner/path")
-    end
-  end
-
-  context "when using URI for escaping" do
-    before { @oldesc, Riak.escaper = Riak.escaper, URI }
-    after { Riak.escaper = @oldesc }
-
-    it "escapes standard non-safe characters" do
-      expect(@object.escape("some string")).to eq("some%20string")
-      expect(@object.escape("another^one")).to eq("another%5Eone")
-      expect(@object.escape("--one+two--")).to eq("--one%2Btwo--")
-    end
-
-    it "allows URI-safe characters" do
-      expect(@object.escape("bracket[one")).to eq("bracket[one")
-      expect(@object.escape("sean@basho")).to eq("sean@basho")
-    end
-
-    it "escapes slashes" do
-      expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
-    end
-
-    it "converts the bucket or key to a string before escaping" do
-      expect(@object.escape(125)).to eq('125')
-    end
-
-    it "unescapes escaped strings" do
-      expect(@object.unescape("some%20string")).to eq("some string")
-      expect(@object.unescape("another%5Eone")).to eq("another^one")
-      expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")
-      expect(@object.unescape("some%2Finner%2Fpath")).to eq("some/inner/path")
-      expect(@object.unescape("--one%2Btwo--")).to eq("--one+two--")
-      expect(@object.unescape("me%40basho.co")).to eq("me@basho.co")
-    end
-  end
-end

data/spec/riak/feature_detection_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'riak/client/feature_detection'
-
-describe Riak::Client::FeatureDetection do
-  let(:klass) {
-    Class.new do
-      include Riak::Client::FeatureDetection
-    end
-  }
-  subject { klass.new }
-
-  context "when the get_server_version is unimplemented" do
-    it "raises a NotImplementedError" do
-      expect { subject.server_version }.to raise_error(NotImplementedError)
-    end
-  end
-
-  context "when the Riak version is 0.14.x" do
-    before { allow(subject).to receive(:get_server_version).and_return("0.14.2") }
-    it { is_expected.not_to be_mapred_phaseless }
-    it { is_expected.not_to be_pb_indexes }
-    it { is_expected.not_to be_pb_search }
-    it { is_expected.not_to be_pb_conditionals }
-    it { is_expected.not_to be_quorum_controls }
-    it { is_expected.not_to be_tombstone_vclocks }
-    it { is_expected.not_to be_pb_head }
-    it { is_expected.not_to be_http_props_clearable }
-  end
-
-  context "when the Riak version is 1.0.x" do
-    before { allow(subject).to receive(:get_server_version).and_return("1.0.3") }
-    it { is_expected.not_to be_mapred_phaseless }
-    it { is_expected.not_to be_pb_indexes }
-    it { is_expected.not_to be_pb_search }
-    it { is_expected.to be_pb_conditionals }
-    it { is_expected.to be_quorum_controls }
-    it { is_expected.to be_tombstone_vclocks }
-    it { is_expected.to be_pb_head }
-    it { is_expected.not_to be_http_props_clearable }
-  end
-
-  context "when the Riak version is 1.1.x" do
-    before { allow(subject).to receive(:get_server_version).and_return("1.1.4") }
-    it { is_expected.to be_mapred_phaseless }
-    it { is_expected.not_to be_pb_indexes }
-    it { is_expected.not_to be_pb_search }
-    it { is_expected.to be_pb_conditionals }
-    it { is_expected.to be_quorum_controls }
-    it { is_expected.to be_tombstone_vclocks }
-    it { is_expected.to be_pb_head }
-    it { is_expected.not_to be_http_props_clearable }
-  end
-
-  context "when the Riak version is 1.2.x" do
-    before { allow(subject).to receive(:get_server_version).and_return("1.2.1") }
-    it { is_expected.to be_mapred_phaseless }
-    it { is_expected.to be_pb_indexes }
-    it { is_expected.to be_pb_search }
-    it { is_expected.to be_pb_conditionals }
-    it { is_expected.to be_quorum_controls }
-    it { is_expected.to be_tombstone_vclocks }
-    it { is_expected.to be_pb_head }
-    it { is_expected.not_to be_http_props_clearable }
-  end
-
-  context "when the Riak version is 1.3.x" do
-    before { allow(subject).to receive(:get_server_version).and_return("1.3.0") }
-    it { is_expected.to be_mapred_phaseless }
-    it { is_expected.to be_pb_indexes }
-    it { is_expected.to be_pb_search }
-    it { is_expected.to be_pb_conditionals }
-    it { is_expected.to be_quorum_controls }
-    it { is_expected.to be_tombstone_vclocks }
-    it { is_expected.to be_pb_head }
-    it { is_expected.to be_http_props_clearable }
-  end
-end