riak-client 2.1.0 → 2.2.0.pre1

data/spec/integration/riak/bucket_types_spec.rb

@@ -2,60 +2,239 @@ require 'spec_helper'
 require 'riak'
 
 describe 'Bucket Types', test_client: true, integration: true do
-  let(:bucket){ random_bucket 'bucket_type_spec' }
-
-  describe 'performing key-value operations' do
-    # for the sake of having a non-default one, not search
-    let(:bucket_type){ 'yokozuna' }
-    let(:object) do
-      object = bucket.new random_key
-      object.data = 'hello'
-      object.content_type = 'text/plain'
-      object.store type: bucket_type
-      object
+
+  describe 'nested bucket types API' do
+    let(:bucket_type){ test_client.bucket_type 'yokozuna' }
+
+    it 'exposes bucket type properties' do
+      expect(props = bucket_type.properties).to be_a Hash
+      expect(props[:allow_mult]).to be
     end
 
-    it 'only retrieves with a bucket type' do
-      expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
-      expect{ bucket.get object.key }.to raise_error /not_found/
+    describe 'performing key-value operations' do
+      let(:bucket){ bucket_type.bucket(random_key) }
+      let(:untyped_bucket){ test_client.bucket bucket.name }
+
+      let(:object) do
+        object = bucket.new random_key
+        object.data = 'hello'
+        object.content_type = 'text/plain'
+        object.store
+        object
+      end
+
+      let(:untyped_object) do
+        untyped_object = untyped_bucket.new object.key
+        untyped_object.data = 'oooops'
+        untyped_object.content_type = 'text/plain'
+        untyped_object.store
+        untyped_object
+      end
+
+      it 'initializes with a bucket type' do
+        o = bucket.new 'lawnmower'
+        o.data = 'reel'
+        o.content_type = 'text/plain'
+        o.store
+
+        expect(bucket.get('lawnmower').data).to eq o.data
+        expect(bucket.exists?('lawnmower')).to be
+      end
+
+      it 'only retrieves with a bucket type' do
+        expect(bucket.get(object.key).data).to eq object.data
+        expect{ untyped_bucket.get object.key }.to raise_error /not_found/
+      end
+
+      it 'reloads with a bucket type' do
+        expect{ object.reload }.to_not raise_error
+        expect(object.data).to eq 'hello'
+      end
+
+      it 'lists keys only for the type' do
+        expect(untyped_bucket).to be # ensure existence
+        expect(object).to be
+
+        expect(untyped_bucket.keys).to be_empty
+        expect(bucket.keys).to include object.key
+      end
+
+      describe 'deletion' do
+        it 'self-deletes with a bucket type' do
+          expect(untyped_object).to be # ensure existence
+          
+          expect(object.delete).to be
+          expect{ object.reload }.to raise_error /not_found/
+          expect(untyped_object).to be
+          expect{ untyped_object.reload }.to_not raise_error
+        end
+
+        it 'deletes from the typed bucket' do
+          expect(untyped_object).to be # ensure existence
+
+          expect(bucket.delete object.key).to be
+          expect{ object.reload }.to raise_error /not_found/
+          expect{ untyped_object.reload }.to_not raise_error
+        end
+      end
+
+      it 'multigets keys' do
+        results = bucket.get_many [object.key]
+        expect(results[object.key]).to be
+        expect(results[object.key].data).to eq object.data
+      end
+
+      describe 'secondary indexes' do
+        it 'finds the correct object with a SecondaryIndex instance' do
+          expect(untyped_object).to be
+          q = Riak::SecondaryIndex.new bucket, '$key', object.key
+
+          expect(q.keys).to include object.key
+          candidate = q.values.first
+          expect(candidate.data).to eq object.data
+        end
+      end
+
+      describe 'map-reduce' do
+        let(:mapred) do
+          Riak::MapReduce.new(test_client) do |mr|
+            mr.map 'function(obj){return [obj.values[0].data];}', keep: true
+          end
+        end
+
+        it 'map-reduces correctly with a typed bucket' do
+          expect(object).to be
+          expect(untyped_object).to be
+
+          mapred.add bucket
+          result = mapred.run
+
+          expect(result).to include object.data
+          expect(result).to_not include untyped_object.data
+        end
+
+        it 'map-reduces correctly with a robject in a typed bucket' do
+          expect(object).to be
+          expect(untyped_object).to be
+          
+          mapred.add object
+          result = mapred.run
+
+          expect(result).to include object.data
+          expect(result).to_not include untyped_object.data
+        end
+      end
     end
 
-    it 'deletes from the bucket only with a bucket type' do
-      expect(bucket.delete object.key).to eq true
-      expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
+    describe 'manipulating bucket properties' do
+      let(:bucket_type){ test_client.bucket_type 'yokozuna' }
+      let(:bucket){ bucket_type.bucket random_key }
+      let(:untyped_bucket){ test_client.bucket bucket.name }
+      
+      it 'allows reading and writing bucket properties' do
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to_not be
+        expect(test_client.get_bucket_props(untyped_bucket)['last_write_wins']).to_not be
+        
+        # test setting
+        expect{ bucket.props = {'last_write_wins' => true} }.to_not raise_error
+
+        # make sure setting doesn't leak to untyped bucket
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to be
+        expect(test_client.get_bucket_props(untyped_bucket)['last_write_wins']).to_not be
+
+        # add canary setting on untyped bucket
+        expect{ untyped_bucket.props = { 'n_val' => 1} }.to_not raise_error
 
-      expect{ bucket.delete object.key, type: bucket_type }.to_not raise_error
-      expect{ bucket.get object.key, type: bucket_type }.to raise_error /not_found/
+        # make sure canary setting doesn't leak to typed bucket
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['n_val']).to_not eq 1
+        expect(test_client.get_bucket_props(untyped_bucket)['n_val']).to eq 1
+
+        # test clearing
+        expect{ bucket.clear_props }.to_not raise_error
+
+        # make sure clearing doesn't leak to canary setting on untyped bucket 
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to_not be
+        expect(test_client.get_bucket_props(untyped_bucket)['n_val']).to eq 1
+      end
     end
 
-    it 'self-deletes only with a bucket type' do
-      expect(object.delete).to be
-      expect{ object.reload type: bucket_type }.to_not raise_error
+    describe 'performing CRDT operations' do
+      let(:bucket_type){ test_client.bucket_type 'other_counters' }
+      let(:bucket){ bucket_type.bucket random_key }
+      let(:counter){ Riak::Crdt::Counter.new bucket, random_key }
+
+      let(:untyped_bucket){ test_client.bucket bucket.name }
+      let(:untyped_counter){ Riak::Crdt::Counter.new untyped_bucket, random_key }
+
+      it 'overrides default bucket types for CRDTs' do
+        expect(untyped_counter.value).to eq 0
+        expect(untyped_counter.bucket_type).to eq Riak::Crdt::DEFAULT_BUCKET_TYPES[:counter]
 
-      expect(object.delete type: bucket_type).to be
-      expect{ object.reload type: bucket_type }.to raise_error /not_found/
+        untyped_counter.increment
+        counter.reload
+
+        expect(counter.value).to eq 0
+        expect(counter.bucket_type).to eq 'other_counters'
+      end
     end
   end
 
-  describe 'performing CRDT set operations' do
-    let(:bucket_type){ Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] }
-    let(:set) do
-      set = Riak::Crdt::Set.new bucket, random_key
-      set.add random_key
-      set
-    end
+  describe 'option-based bucket types API' do
+    let(:bucket){ random_bucket 'bucket_type_spec' }
+
+    describe 'performing key-value operations' do
+      # for the sake of having a non-default one, not search
+      let(:bucket_type){ 'yokozuna' }
+      let(:object) do
+        object = bucket.new random_key
+        object.data = 'hello'
+        object.content_type = 'text/plain'
+        object.store type: bucket_type
+        object
+      end
+
+      it 'only retrieves with a bucket type' do
+        expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
+        expect{ bucket.get object.key }.to raise_error /not_found/
+      end
+
+      it 'deletes from the bucket only with a bucket type' do
+        expect(bucket.delete object.key).to eq true
+        expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
 
-    it 'retrieves the set blob via key-value using a bucket type' do
-      expect{ bucket.get set.key }.to raise_error /not_found/
-      expect(bucket.get set.key, type: bucket_type).to be
+        expect{ bucket.delete object.key, type: bucket_type }.to_not raise_error
+        expect{ bucket.get object.key, type: bucket_type }.to raise_error /not_found/
+      end
+
+      it 'self-deletes only with a bucket type' do
+        expect(object.delete).to be
+        expect{ object.reload type: bucket_type }.to_not raise_error
+
+        expect(object.delete type: bucket_type).to be
+        expect{ object.reload type: bucket_type }.to raise_error /not_found/
+      end
     end
 
-    it 'deletes the set blob through the bucket type' do
-      expect(bucket.delete set.key).to be
-      expect{ bucket.get set.key, type: bucket_type }.to_not raise_error
+    describe 'performing CRDT set operations' do
+      let(:bucket_type){ Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] }
+      let(:set) do
+        set = Riak::Crdt::Set.new bucket, random_key
+        set.add random_key
+        set
+      end
+
+      it 'retrieves the set blob via key-value using a bucket type' do
+        expect{ bucket.get set.key }.to raise_error /not_found/
+        expect(bucket.get set.key, type: bucket_type).to be
+      end
+
+      it 'deletes the set blob through the bucket type' do
+        expect(bucket.delete set.key).to be
+        expect{ bucket.get set.key, type: bucket_type }.to_not raise_error
 
-      expect(bucket.delete set.key, type: bucket_type).to be
-      expect{ bucket.get set.key, type: bucket_type }.to raise_error /not_found/
+        expect(bucket.delete set.key, type: bucket_type).to be
+        expect{ bucket.get set.key, type: bucket_type }.to raise_error /not_found/
+      end
     end
   end
 end

data/spec/integration/riak/conflict_resolution_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'riak'
+
+describe 'Conflict resolution', integration: true, test_client: true do
+  let(:bucket) do
+    bucket = random_bucket
+    bucket.allow_mult = true
+
+    bucket
+  end
+
+  subject do
+    robj = bucket.new
+    robj.content_type = 'application/json'
+    robj.data = 100
+    robj.store
+
+    robj
+  end
+
+  let(:ten_conflicted_robjects) do
+    10.times.map do |n|
+      t = bucket.new subject.key
+      t.data = rand 50
+      t.store
+
+      t
+    end
+  end
+
+  before(:each) do
+    ten_conflicted_robjects
+    subject.reload
+  end
+
+  describe 'on_conflict hooks' do
+    after(:each) do
+      Riak::RObject.on_conflict_hooks.delete_if{ |i| true }
+    end
+
+    it 'resolve ten-sided conflicts' do
+      expect(subject).to be_conflict
+
+      # resolver
+      Riak::RObject.on_conflict do |obj|
+        next nil unless obj.siblings.first.data.is_a? Numeric
+        new_sibling = obj.siblings.inject do |memo, sib|
+          memo.data = [memo.data, sib.data].max
+
+          memo
+        end
+
+        obj.siblings = [new_sibling.dup]
+
+        obj
+      end
+
+      subject.attempt_conflict_resolution
+      subject.reload
+      
+      expect(subject).to_not be_conflict
+      expect(subject.data).to eq 100
+
+    end
+
+    it "doesn't resolve impossible conflicts" do
+      expect(subject).to be_conflict
+
+      Riak::RObject.on_conflict do |obj|
+        nil
+      end
+
+      subject.reload
+
+      expect(subject).to be_conflict
+    end
+  end
+
+  describe 'clobbering siblings without a hook' do
+    it 'resolves ten-sided conflicts' do
+      expect(subject).to be_conflict
+      expect(subject.siblings.length).to eq 11
+      max_sibling = subject.siblings.inject do |memo, sib|
+        next memo if memo.data > sib.data
+        next sib
+      end
+
+      subject.siblings = [max_sibling]
+      subject.store
+
+      subject.reload
+      expect(subject).to_not be_conflict
+      expect(subject.data).to eq 100
+    end
+  end
+end

data/spec/integration/riak/crdt_spec.rb

@@ -15,8 +15,25 @@ describe "CRDTs", integration: true, test_client: true do
       expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq 'sets'
     end
 
-    it "allows override bucket-types for instances" do
-      expect(Riak::Crdt::Set.new(bucket, 'set', 'other_bucket_type').bucket_type).to eq 'other_bucket_type'
+    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
 
@@ -146,6 +163,7 @@ describe "CRDTs", integration: true, test_client: true do
       expect(subject.include? 'coffee').to be
     end
   end
+
   describe 'maps' do
     subject { Riak::Crdt::Map.new bucket, random_key }
 
@@ -233,6 +251,11 @@ describe "CRDTs", integration: true, test_client: true do
 
         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
@@ -241,6 +264,11 @@ describe "CRDTs", integration: true, test_client: true do
 
         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
 end

data/spec/integration/riak/properties_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'riak/bucket_properties'
+
+describe Riak::BucketProperties, test_client: true, integration: true do
+  describe 'Bucket Properties objects' do
+    let(:bucket){ random_bucket 'props' }
+    subject{ described_class.new bucket }
+
+    let(:other_bucket) do
+      random_bucket('props-other').tap do |b|
+        p = described_class.new b
+        p['r'] = 1
+        p.store
+      end
+    end
+    let(:other_props){ described_class.new other_bucket }
+
+    before(:example) do
+      bucket.clear_props
+      subject.reload
+    end
+
+    it 'is initializable with a bucket' do
+      expect{ described_class.new bucket }.to_not raise_error
+    end
+
+    it 'works like a hash' do
+      expect(subject['r']).to eq 'quorum'
+      expect{ subject['r'] = 1 }.to_not raise_error
+      subject.store
+      subject.reload
+
+      expect(subject['r']).to eq 1
+    end
+
+    it 'can be merged from a hash' do
+      bulk_props = { r: 1, w: 1, dw: 1 }
+      expect{ subject.merge! bulk_props }.to_not raise_error
+      subject.store
+      subject.reload
+
+      expect(subject['r']).to eq 1
+      expect(subject['w']).to eq 1
+      expect(subject['dw']).to eq 1
+    end
+
+    it 'can be merged from a bucket properties object' do
+      expect(other_props['r']).to eq 1
+      expect(subject['r']).to eq 'quorum'
+
+      expect{ subject.merge! other_props }.to_not raise_error
+      subject.store
+      subject.reload
+
+      expect(subject['r']).to eq 1
+    end
+
+    let(:modfun){ { 'mod' => 'validate_json', 'fun' => 'validate' } }
+
+    it 'works with composite/modfun properties' do
+      expect{ subject['precommit'] = modfun }.to_not raise_error
+
+      subject.store
+      subject.reload
+
+      expect(subject['precommit']).to eq [modfun]
+    end
+  end
+end

data/spec/integration/riak/search_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'riak/search'
+
+describe 'Object-oriented Search API', test_client: true, integration: true, search_config: true do
+  before :all do
+    create_index
+    configure_bucket
+    load_corpus
+  end
+
+  let(:term){ 'bitcask' }
+
+  describe 'queries' do
+    let(:index){ Riak::Search::Index.new test_client, index_name }
+    subject { Riak::Search::Query.new test_client, index, term }
+
+    it 'performs queries' do
+      results = nil
+      expect{ results = subject.results }.to_not raise_error
+      expect(results.raw).to_not be_empty 
+      expect(results).to_not be_empty
+    end
+
+    it 'performs limited and sorted queries' do
+      subject.rows = 5
+      results = nil
+      expect{ results = subject.results }.to_not raise_error
+      expect(results.raw).to_not be_empty
+      expect(results.length).to eq 5
+    end
+  end
+
+  describe 'results from queries' do
+    let(:index){ Riak::Search::Index.new test_client, index_name }
+    let(:query){ Riak::Search::Query.new test_client, index, term }
+    subject { query.results }
+    
+    it 'exposes search-result documents' do
+      expect(subject).to_not be_empty
+
+      expect(subject.docs).to_not be_empty
+      expect(first = subject.docs.first).to be
+
+      expect(first.score).to be_a Numeric
+
+      expect(first.bucket_type).to be_a Riak::BucketType
+      expect(first.bucket).to be_a Riak::Bucket
+      expect(first.key).to be_a String
+    end
+
+    it 'exposes RObjects' do
+      expect(subject).to_not be_empty
+      
+      expect(first = subject.first).to be_a Riak::RObject
+      expect(first).to eq subject.docs.first.robject
+
+      expect(first.key).to eq subject.docs.first.key
+    end
+  end
+
+  describe 'indexes' do
+    it 'tests for index existence and content' do
+      existing_index = Riak::Search::Index.new test_client, index_name
+      expect(existing_index).to be_exists # auto predicate matcher
+
+      nonexistent_index = Riak::Search::Index.new(test_client, "nonexist-#{random_key}")
+      expect(nonexistent_index).to_not be_exists
+    end
+
+    it 'creates indexes' do
+      new_index = Riak::Search::Index.new test_client, "search-spec-#{random_key}"
+      expect(new_index).to_not be_exist
+      expect{ new_index.create! }.to_not raise_error
+
+      wait_until{ new_index.exists? }
+
+      expect(new_index).to be_exists
+
+      expect{ new_index.create! }.to raise_error Riak::SearchError::IndexExistsError
+    end
+  end
+
+  describe 'schemas' do
+    it 'tests for schema existence and content' do
+      existing_schema = Riak::Search::Schema.new test_client, '_yz_default'
+      expect(existing_schema).to be_exists
+
+      nonexistent_schema = Riak::Search::Schema.new(test_client, "nonexist-#{random_key}")
+      expect(nonexistent_schema).to_not be_exists
+    end
+
+    it 'creates schemas' do
+      new_schema = Riak::Search::Schema.new test_client, "search-spec-#{random_key}"
+      expect(new_schema).to_not be_exist
+      expect{ new_schema.create! schema_xml(new_schema.name) }.to_not raise_error
+
+      wait_until{ new_schema.exists? }
+
+      expect(new_schema).to be_exists
+
+      expect{ new_schema.create! schema_xml(new_schema.name) }.to raise_error Riak::SearchError::SchemaExistsError
+    end
+  end
+end

data/spec/integration/riak/secondary_index_spec.rb

@@ -51,4 +51,22 @@ describe 'Secondary indexes', test_client: true, integration: true do
     expect(terms['20']).to be
     expect(terms['19']).to be_empty
   end
+
+  describe "with symbolized index names" do
+    it "stores and queries indexes correctly" do
+      obj = bucket.new random_key
+      obj.indexes[:coat_pattern_bin] << "tuxedo"
+      obj.data = "tuxedo"
+
+      expect{ obj.store }.to_not raise_error
+
+      results = nil
+      expect do
+        results = bucket.get_index(:coat_pattern_bin,
+                                   'tuxedo')
+      end.to_not raise_error
+
+      expect(results.first).to eq obj.key
+    end
+  end
 end