riak-client 2.5.0 → 2.6.0

data/spec/integration/riak/counters_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'riak'
-
-describe Riak::Counter, test_client: true, integration: true do
-  before :all do
-    @bucket = random_bucket 'counter_spec'
-    @bucket.allow_mult = true
-
-    @counter = Riak::Counter.new @bucket, 'counter_spec'
-  end
-
-  it 'reads and updates' do
-    initial = @counter.value
-
-    @counter.increment
-    @counter.increment
-
-    expect(@counter.value).to eq(initial + 2)
-
-    @counter.decrement 2
-
-    expect(@counter.value).to eq(initial)
-
-    5.times do
-      amt = rand(10_000)
-
-      @counter.increment amt
-      expect(@counter.value).to eq(initial + amt)
-
-      @counter.decrement (amt * 2)
-      expect(@counter.value).to eq(initial - amt)
-
-      expect(@counter.increment_and_return(amt)).to eq(initial)
-    end
-  end
-end

data/spec/integration/riak/crdt/configuration_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'riak'
-
-describe "CRDT configuration", integration: true, test_client: true do
-  SETS = Riak::Crdt::DEFAULT_BUCKET_TYPES[:set]
-  let(:bucket) { random_bucket }
-
-  it "allows default bucket-types to be configured for each data type" do
-    expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq SETS
-
-    Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] = 'new_set_default'
-    expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq 'new_set_default'
-
-    Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] = SETS
-    expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq SETS
-  end
-
-  describe 'overriding bucket-types' do
-    let(:name){ 'other_counters' }
-    let(:type){ test_client.bucket_type name }
-    let(:typed_bucket){ type.bucket bucket.name }
-
-    it "overrides with a string" do
-      ctr = Riak::Crdt::Counter.new(bucket, 'ctr', name)
-      expect(ctr.bucket_type).to eq name
-    end
-
-    it "overrides with a typed bucket" do
-      ctr = Riak::Crdt::Counter.new(typed_bucket, 'ctr')
-      expect(ctr.bucket_type).to eq name
-    end
-
-    it "overrides with a bucket type object" do
-      ctr = Riak::Crdt::Counter.new(bucket, 'ctr', type)
-      expect(ctr.bucket_type).to eq name
-    end
-  end
-end

data/spec/integration/riak/crdt_search_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-require 'riak/search'
-
-describe 'CRDT Search API', crdt_search_config: true do
-  describe 'querying maps' do
-    let(:query) { index.query 'arroz_register:frijoles' }
-
-    before(:all) do
-      expect(first_map).to be
-    end
-
-    subject{ query.results }
-
-    it 'finds maps' do
-      expect(subject.length).to be > 0
-    end
-
-    it 'provides access to maps through the #map accessor' do
-      expect(subject.maps.first).to eq first_map
-      expect(subject.docs.first.map).to eq first_map
-    end
-
-    it 'provides access to maps through the #crdt accessor' do
-      expect(subject.crdts.first).to eq first_map
-      expect(subject.docs.first.crdt).to eq first_map
-    end
-
-    it 'provides access to maps through the #object accessor' do
-      expect(subject.first).to eq first_map
-      expect(subject.docs.first.object).to eq first_map
-    end
-
-    it 'raises errors on the set, counter, and robject accessors' do
-      expect{ subject.docs.first.robject }.
-        to raise_error Riak::SearchError::UnexpectedResultError
-      expect{ subject.docs.first.counter }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-      expect{ subject.docs.first.set }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-    end
-  end
-
-  describe 'querying sets' do
-    let(:query) { index.query 'set:frijoles' }
-
-    before(:all) do
-      expect(first_set).to be
-    end
-
-    subject{ query.results }
-
-    it 'finds sets' do
-      expect(subject.length).to be > 0
-    end
-
-    it 'provides access to sets through the #set accessor' do
-      expect(subject.sets.first).to eq first_set
-      expect(subject.docs.first.set).to eq first_set
-    end
-
-    it 'provides access to sets through the #object accessor' do
-      expect(subject.first).to eq first_set
-      expect(subject.docs.first.object).to eq first_set
-    end
-
-    it 'raises errors on the counter, map, and robject accessors' do
-      expect{ subject.docs.first.robject }.
-        to raise_error Riak::SearchError::UnexpectedResultError
-      expect{ subject.docs.first.counter }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-      expect{ subject.docs.first.map }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-    end
-  end
-
-  describe 'querying counters' do
-    let(:query) { index.query 'counter:83475' }
-
-    before(:all) do
-      expect(first_counter).to be
-    end
-
-    subject{ query.results }
-
-    it 'finds counters' do
-      expect(subject.length).to be > 0
-    end
-
-    it 'provides access to counters through the #counter accessor' do
-      expect(subject.counters.first).to eq first_counter
-      expect(subject.docs.first.counter).to eq first_counter
-    end
-
-    it 'provides access to counters through the #object accessor' do
-      expect(subject.first).to eq first_counter
-      expect(subject.docs.first.object).to eq first_counter
-    end
-
-    it 'raises errors on the counter, map, and robject accessors' do
-      expect{ subject.docs.first.robject }.
-        to raise_error Riak::SearchError::UnexpectedResultError
-      expect{ subject.docs.first.set }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-      expect{ subject.docs.first.map }.
-        to raise_error Riak::CrdtError::UnexpectedDataType
-    end
-  end
-
-  describe 'querying multiple kinds of CRDT' do
-    let(:query) do
-      index.query 'arroz_register:frijoles OR set:frijoles OR counter:83475'
-    end
-    subject{ query.results }
-
-    before(:all) do
-      expect(first_counter).to be
-      expect(first_map).to be
-      expect(first_set).to be
-    end
-
-    it 'finds CRDTs' do
-      expect(subject.length).to be >= 3
-    end
-
-    it 'provides access through appropriate accessors' do
-      expect(subject.counters.first).to eq first_counter
-      expect(subject.maps.first).to eq first_map
-      expect(subject.sets.first).to eq first_set
-      expect(subject.crdts).to include first_counter
-      expect(subject.crdts).to include first_map
-      expect(subject.crdts).to include first_set
-    end
-
-    it 'allows looping through each object' do
-      # I worry that this may be order-dependent and occasionally fail
-      expect{ |b| subject.crdts.each &b }.
-        to yield_successive_args(first_counter, first_map, first_set)
-    end
-
-    it 'allows looping through each kind of object' do
-      expect{ |b| subject.counters.each &b }.to yield_with_args(first_counter)
-      expect{ |b| subject.maps.each &b }.to yield_with_args(first_map)
-      expect{ |b| subject.sets.each &b }.to yield_with_args(first_set)
-    end
-  end
-
-  describe 'querying both CRDTs and RObjects' do
-    let(:query) do
-      index.query 'arroz_register:frijoles OR set:frijoles OR counter:83475 OR "bitcask"'
-    end
-    subject{ query.results }
-
-    before(:all) do
-      load_corpus
-      expect(first_counter).to be
-      expect(first_map).to be
-      expect(first_set).to be
-    end
-
-    let(:first_robject){ subject.robjects.first }
-
-    it 'finds CRDTs and RObjects' do
-      expect(subject.objects).to include first_counter
-      expect(subject.objects).to include first_map
-      expect(subject.objects).to include first_set
-      expect(subject.objects).to include first_robject
-    end
-
-    it 'provides access through appropriate accessors' do
-      expect(subject.crdts).to_not include first_robject
-      expect(subject.robjects).to_not include first_counter
-      expect(subject.robjects).to_not include first_map
-      expect(subject.robjects).to_not include first_set
-    end
-  end
-end

data/spec/integration/riak/crdt_spec.rb

@@ -1,332 +0,0 @@
-require 'spec_helper'
-require 'riak'
-require 'riak/errors/failed_request'
-
-describe "CRDTs", integration: true, test_client: true do
-  let(:bucket) { random_bucket }
-
-  describe 'Riak-assigned names' do
-    describe 'an anonymous counter' do
-      subject { Riak::Crdt::Counter.new bucket, nil }
-      it 'accepts a Riak-assigned name' do
-        subject.increment
-        expect(subject.key).to be
-        expect(subject.value).to eq 1
-      end
-    end
-
-    describe 'an anonymous set' do
-      subject { Riak::Crdt::Set.new bucket, nil }
-      it 'accepts a Riak-assigned name' do
-        subject.add 'sandwich'
-        expect(subject.key).to be
-        expect(subject).to include 'sandwich'
-      end
-    end
-
-    describe 'an anonymous map' do
-      subject { Riak::Crdt::Map.new bucket, nil }
-      it 'accepts a Riak-assigned name' do
-        subject.registers['coat_pattern'] = 'tabby'
-        expect(subject.key).to be
-        expect(subject.registers['coat_pattern']).to eq 'tabby'
-      end
-    end
-  end
-
-  describe 'counters' do
-    subject { Riak::Crdt::Counter.new bucket, random_key }
-    it 'allows straightforward counter ops' do
-      start = subject.value
-      subject.increment
-      expect(subject.value).to eq(start + 1)
-      subject.increment
-      expect(subject.value).to eq(start + 2)
-      subject.increment -1
-      expect(subject.value).to eq(start + 1)
-      subject.decrement
-      expect(subject.value).to eq(start)
-    end
-
-    it 'allows batched counter ops' do
-      start = subject.value
-      subject.batch do |s|
-        s.increment
-        s.increment 2
-        s.increment
-        s.increment
-      end
-      expect(subject.value).to eq(start + 5)
-    end
-
-    it 'asks for and accepts a returned body by default' do
-      other = Riak::Crdt::Counter.new subject.bucket, subject.key
-
-      start = subject.value
-
-      expect(subject.value).to eq start
-
-      other.increment 10
-
-      subject.increment 1
-
-      expect(subject.dirty?).to_not be
-      expect(subject.value).to eq(start + 10 + 1)
-    end
-
-    describe 'equality' do
-      let(:same){ Riak::Crdt::Counter.new subject.bucket, subject.key }
-      let(:same_bucket){ Riak::Bucket.new test_client, bucket.name }
-      let(:similar){ Riak::Crdt::Counter.new same_bucket, subject.key }
-      it { is_expected.to eq subject }
-      it { is_expected.to eq same }
-      it { is_expected.to eq similar }
-    end
-  end
-
-  describe 'sets' do
-
-    subject { Riak::Crdt::Set.new bucket, random_key }
-
-    it 'allows straightforward set ops' do
-      start = subject.members
-      addition = random_key
-
-      subject.add addition
-      expect(subject.include? addition).to be
-      expect(subject.members).to include(addition)
-
-      subject.remove addition
-      expect(subject.include? addition).to_not be
-      expect(subject.members).to_not include(addition)
-      expect(subject.members).to eq(start)
-    end
-
-    it 'lets Riak silently accept removals after reload' do
-      addition = random_key
-      subject.add addition
-
-      other = Riak::Crdt::Set.new subject.bucket, subject.key
-      expect{ other.remove addition }.to raise_error(Riak::CrdtError::SetRemovalWithoutContextError)
-      other.reload
-      expect{ other.remove addition }.to_not raise_error
-      other.reload
-      expect{ other.remove 'an element not in the set' }.to_not raise_error
-    end
-
-    it 'allows batched set ops' do
-      subject.add 'zero'
-      subject.reload
-
-      subject.batch do |s|
-        s.add 'first'
-        s.remove 'zero'
-      end
-
-      expect(subject.members.to_a).to eq %w{first}
-    end
-
-    it 'asks for and accepts a returned body by default' do
-      other = Riak::Crdt::Set.new subject.bucket, subject.key
-
-      expect(subject.include? 'coffee').to_not be
-      expect(other.include? 'coffee').to_not be
-
-      other.add 'coffee'
-      subject.add 'tea'
-
-      expect(subject.dirty?).to_not be
-
-      expect(other.include? 'coffee').to be
-      expect(subject.include? 'coffee').to be
-    end
-  end
-
-  describe 'maps' do
-    subject { Riak::Crdt::Map.new bucket, random_key }
-
-    it 'allows straightforward map ops' do
-      subject.registers['first'] = 'hello'
-      expect(subject.registers['first']).to eq('hello')
-
-      subject.sets['arnold'].add 'commando'
-      subject.sets['arnold'].add 'terminator'
-      expect(subject.sets['arnold'].members).to include('commando')
-      subject.sets['arnold'].remove 'commando'
-      expect(subject.sets['arnold'].members).to_not include('commando')
-      expect(subject.sets['arnold'].members).to include('terminator')
-
-      subject.maps['first'].registers['second'] = 'good evening'
-      subject.maps['first'].maps['third'].counters['fourth'].increment
-
-      expect(subject.maps['first'].registers['second']).to eq('good evening')
-      expect(subject.maps['first'].maps['third'].counters['fourth'].value).to eq(1)
-
-      subject.counters['hits'].increment
-      expect(subject.counters['hits'].value).to eq 1
-
-      subject.flags['yes'] = true
-      expect(subject.flags['yes']).to eq true
-
-      expect do
-        subject.registers.delete 'first'
-        subject.sets.delete 'arnold'
-        subject.maps.delete 'first'
-        subject.counters.delete 'hits'
-        subject.flags.delete 'yes'
-      end.to_not raise_error
-    end
-
-    it 'allows batched map ops' do
-      subject.batch do |s|
-        s.registers['condiment'] = 'ketchup'
-        s.counters['banana'].increment
-      end
-
-      expect(subject.registers['condiment']).to eq 'ketchup'
-      expect(subject.counters['banana'].value).to eq 1
-    end
-
-    it 'asks for and accepts a returned body by default' do
-      other = Riak::Crdt::Map.new subject.bucket, subject.key
-
-      expect(subject.sets['bees'].include? 'honey').to_not be
-      expect(other.sets['bees'].include? 'honey').to_not be
-
-      other.sets['bees'].add 'honey'
-      subject.counters['stings'].increment
-
-      expect(subject.dirty?).to_not be
-
-      expect(other.sets['bees'].include? 'honey').to be
-      expect(subject.sets['bees'].include? 'honey').to be
-    end
-
-    describe 'containing a map' do
-      it 'bubbles straightforward map ops up' do
-        street_map = subject.maps['street']
-
-        street_map.registers['bird'] = 'avenue'
-        street_map.flags['traffic_light'] = false
-
-        expect(subject.maps['street'])
-      end
-
-      it 'includes inner-map ops in the outer-map batch' do
-        subject.batch do |m|
-          m.maps['road'].counters['speedbumps'].increment 4
-          m.maps['road'].sets['signs'].add 'yield'
-        end
-
-        expect(subject.maps['road'].counters['speedbumps'].value).to eq 4
-        expect(subject.maps['road'].sets['signs'].include? 'yield').to be
-      end
-
-      it 'deletes nested inner-map' do
-        bag_map = subject.maps['bag']
-        inner_map = bag_map.maps['123']
-        inner_map.registers['name'] = 'f1'
-
-        expect(subject.maps['bag'].maps['123'].registers['name']).to eq 'f1'
-
-        expect{ bag_map.maps.delete('123') }.to_not raise_error
-        expect(bag_map.maps.include? '123').to_not be
-        expect(bag_map.maps['123'].registers['name']).to_not be
-      end
-    end
-
-    describe 'containing a register' do
-      it 'bubbles straightforward register ops up' do
-        subject.registers['hkey_local_machine'] = 'registry'
-
-        expect(subject.registers['hkey_local_machine']).to eq 'registry'
-      end
-
-      it "doesn't error on an unset register" do
-        expect{ subject.registers['unset'] }.to_not raise_error
-        expect(subject.registers['other_unset']).to_not be
-      end
-    end
-
-    describe 'containing a flag' do
-      it 'bubbles straightforward flag ops up' do
-        subject.flags['enable_magic'] = true
-
-        expect(subject.flags['enable_magic']).to be
-      end
-
-      it "doesn't error on an unset flag" do
-        expect{ subject.flags['unset'] }.to_not raise_error
-        expect(subject.flags['other_unset']).to_not be
-      end
-    end
-  end
-
-  describe 'HLLs', hll: true do
-    before(:each) do
-      begin
-        hlls = test_client.bucket_type Riak::Crdt::DEFAULT_BUCKET_TYPES[:hll]
-        hlls.properties
-      rescue Riak::ProtobuffsErrorResponse
-        skip('HyperLogLog bucket-type not found or active.')
-      end
-    end
-
-    subject { Riak::Crdt::HyperLogLog.new bucket, random_key }
-
-    it 'allows straightforward HLL ops' do
-      addition = random_key
-
-      subject.add addition
-
-      expect(subject.value).to be_a(Integer)
-      expect(subject.value).to eq 1
-    end
-
-    it 'asks for and accepts a returned body by default' do
-      other = Riak::Crdt::HyperLogLog.new subject.bucket, subject.key
-
-      other.add 'coffee'
-
-      expect(other.value).to be_a(Integer)
-      expect(other.value).to eq 1
-
-      expect(subject.value).to eq 1
-
-      subject.add 'tea'
-
-      expect(subject.value).to be_a(Integer)
-      expect(subject.value).to eq 2
-
-      other.reload
-      expect(other.value).to eq 2
-
-      other.add 'juice'
-
-      expect(other.value).to be_a(Integer)
-      expect(other.value).to eq 3
-
-      # repeat input to verify the HLL value doesn't increment
-      other.add 'juice'
-
-      expect(other.value).to be_a(Integer)
-      expect(other.value).to eq 3
-
-      expect(subject.dirty?).to_not be
-    end
-
-    it 'allows batched HLL ops' do
-      subject.add 'zero'
-      subject.reload
-
-      subject.batch do |s|
-        s.add 'first'
-        s.add 'second'
-        s.add 'second'
-      end
-
-      expect(subject.value).to be_a(Integer)
-      expect(subject.value).to eq 3
-    end
-  end
-end