riak-client 2.5.0 → 2.6.0

data/spec/fixtures/multipart-with-unmarked-tombstone.txt

@@ -1,16 +0,0 @@
-
---CvfrSTCWwIiwezy0Zt1B2zwKgS7
-Content-Type: multipart/mixed; boundary=E9n2ZOKHIazIoPHzXj9XsWYWJjJ
-
---E9n2ZOKHIazIoPHzXj9XsWYWJjJ
-X-Riak-Vclock: a85hYGBgzGDKBVIcypz/fvpN53+WwZTIlMfKcNVJ6ARfFgA=
-Location: /buckets/links/keys/target
-Content-Type: application/octet-stream
-Link: </buckets/links>; rel="up"
-Etag: 50FOyLo7juvEVUO33MRJwP
-Last-Modified: Tue, 18 Oct 2011 18:35:01 GMT
-
-
---E9n2ZOKHIazIoPHzXj9XsWYWJjJ--
-
---CvfrSTCWwIiwezy0Zt1B2zwKgS7--

data/spec/fixtures/server.cert.crt

@@ -1,15 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICPzCCAagCCQDfZhEdJjSgTDANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJV
-UzELMAkGA1UECBMCTkMxEjAQBgNVBAcTCUNoYXJsb3R0ZTEOMAwGA1UEChMFQmFz
-aG8xEDAOBgNVBAsTB1N1cHBvcnQxEjAQBgNVBAMTCTEyNy4wLjAuMTAeFw0xMTAz
-MjYxNjMzMzNaFw0zODA4MTAxNjMzMzNaMGQxCzAJBgNVBAYTAlVTMQswCQYDVQQI
-EwJOQzESMBAGA1UEBxMJQ2hhcmxvdHRlMQ4wDAYDVQQKEwVCYXNobzEQMA4GA1UE
-CxMHU3VwcG9ydDESMBAGA1UEAxMJMTI3LjAuMC4xMIGfMA0GCSqGSIb3DQEBAQUA
-A4GNADCBiQKBgQCtfHMCsR86HQEAsO52/WvtFWCEigXll0rxYjXvdqeszEPEMFIy
-Qlg3GlRxH51YrBzp46ReF9Qv5sf0Nh6SR7HGzlWmMEVfPeuAKcz1fzVcjD+IXWHK
-qklAQjpxz+18dvaGxQ7ZJMPsBlq1v64siTLXI0yhjxXOuQPJWrWsvuuXkQIDAQAB
-MA0GCSqGSIb3DQEBBQUAA4GBAIqt1A5Ah7s2oUoYQ8YCKC83fKbXbbNCiLFLwIzy
-TGYXd8j7JTfeY8ettbtitlYgP+ouf23LzonuMo47GRuMgVKRWm4l+ZVMP5Qbkx9t
-uspx+6lHUWnMT9aRdP9/2I7dscyfuhtzs0UxddADLzL9Cif4Y06E1NhR/KK+zo46
-Nep8
------END CERTIFICATE-----

data/spec/fixtures/server.cert.key

@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXQIBAAKBgQCtfHMCsR86HQEAsO52/WvtFWCEigXll0rxYjXvdqeszEPEMFIy
-Qlg3GlRxH51YrBzp46ReF9Qv5sf0Nh6SR7HGzlWmMEVfPeuAKcz1fzVcjD+IXWHK
-qklAQjpxz+18dvaGxQ7ZJMPsBlq1v64siTLXI0yhjxXOuQPJWrWsvuuXkQIDAQAB
-AoGBAJIguzdPPgBTId8VKSes+lVupie9oo3qy8NaeBfGGCIixAnisbmHzIpNcUb/
-3CcuggQ4LODcrWvTtiTr2QBZx1FL7E4POBJl/N7zJMaQd+pGjmrJGfv5haSSQN+H
-r74Ix3HCd0RPdSgt5pmlT4KfsqkfRmqsPd6Nw54zbyLFMlTpAkEA4ar3ZJi2+Y+u
-FH3AycXuPdDtVW0tKFtxfvKlS48gshB6gmkd06Ugss5eZkdbSY0voAp88Tr2shOJ
-+pXc++Zl6wJBAMTN9K9k728cVCf41pR6mDVxIaaqjJeY4DWppGQFSqw/fmYz/Quu
-PlTvk6pGRYiGN6y9CZFNoL2I/SWcd4ukrXMCQCyfYOHsbKn2Zka5Awki8VQZ3wQ4
-XWiQhGXE1ziUqbNsHL1yyaoTCd8xfWseCwgFOficek49CZD22h7JyXOqAFcCQCn2
-mFPFu9//NFqJjod+VHIgu0IkX3H7oOMQVwMUtcVgjH0SXMRe1N+bbesCrNTdeYWV
-kTKwULPZP9EDOeJGrM0CQQCsX+8VZ15yKTy6ADINrOt26PNpD4ib4552TE6T/1wG
-LKdjn5l0qB5K7ILc22z3LCenNBa0Uxbg5/RSdoX57aHA
------END RSA PRIVATE KEY-----

data/spec/fixtures/test.pem

@@ -1 +0,0 @@
-i-am-a-pem

data/spec/fixtures/yz_schema_template.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<schema name="SCHEMA_NAME" version="1.5">
-<fields>
-   <field name="_yz_id" type="_yz_str" indexed="true" stored="true" multiValued="false" required="true" />
-   <field name="_yz_ed" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_pn" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_fpn" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_vtag" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_rk" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_rb" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_rt" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-   <field name="_yz_err" type="_yz_str" indexed="true" stored="true" multiValued="false"/>
-</fields>
-<uniqueKey>_yz_id</uniqueKey>
-<types>
-    <fieldType name="_yz_str" class="solr.StrField" sortMissingLast="true" />
-</types>
-</schema>

data/spec/integration/riak/bucket_types_spec.rb

@@ -1,308 +0,0 @@
-require 'spec_helper'
-require 'riak'
-
-describe 'Bucket Types', test_client: true, integration: true do
-
-  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
-
-    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
-
-      describe 'loading and modifying a RObject' do
-        it "doesn't modify objects in other buckets" do
-          expect(o = bucket.get(object.key)).to be
-          o.data = 'updated'
-          o.store
-          o.reload
-
-          expect(o.data).to eq 'updated'
-
-          expect{ untyped_bucket.get(object.key)}.to raise_error(/not found/)
-
-          expect(o3 = bucket.get(object.key)).to be
-          expect(o3.data).to eq o.data
-        end
-
-        it "doesn't delete objects in other buckets'" do
-          expect{ untyped_object.reload }.to_not raise_error
-
-          expect(o = bucket.get(object.key)).to be
-          o.delete
-
-          expect{ untyped_object.reload }.to_not raise_error
-        end
-      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
-
-      it 'keeps the bucket type attached to value objects' do
-        expect(bucket.get(object.key).bucket).to eq bucket
-        expect(bucket.get(object.key).bucket.type).to eq bucket_type
-      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
-
-    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')['notfound_ok']).to be
-        expect(test_client.get_bucket_props(untyped_bucket)['notfound_ok']).to be
-
-        # test setting
-        expect{ bucket.props = {'notfound_ok' => false} }.to_not raise_error
-
-        # make sure setting doesn't leak to untyped bucket
-        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['notfound_ok']).to_not be
-        expect(test_client.get_bucket_props(untyped_bucket)['notfound_ok']).to be
-
-        # add canary setting on untyped bucket
-        expect{ untyped_bucket.props = { 'n_val' => 1} }.to_not raise_error
-
-        # 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')['notfound_ok']).to be
-        expect(test_client.get_bucket_props(untyped_bucket)['n_val']).to eq 1
-      end
-    end
-
-    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]
-
-        untyped_counter.increment
-        counter.reload
-
-        expect(counter.value).to eq 0
-        expect(counter.bucket_type).to eq 'other_counters'
-      end
-    end
-  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
-
-        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
-
-    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/
-      end
-    end
-
-    describe 'performing CRDT HLL operations', 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
-
-      let(:bucket_type){ Riak::Crdt::DEFAULT_BUCKET_TYPES[:hll] }
-      let(:hll) do
-        hyper_log_log = Riak::Crdt::HyperLogLog.new bucket, random_key, bucket_type
-        hyper_log_log.add random_key
-        hyper_log_log
-      end
-      let(:empty_hll) do
-        Riak::Crdt::HyperLogLog.new bucket, random_key, bucket_type
-      end
-
-      it 'defaults to 0 for a new key' do
-        expect(empty_hll.cardinality).to eq 0
-      end
-
-      it 'retrieves the HLL blob via key-value using a bucket type' do
-        expect{ bucket.get hll.key }.to raise_error /not_found/
-        expect(bucket.get hll.key, type: bucket_type).to be
-      end
-
-      it 'deletes the HLL blob through the bucket type' do
-        expect(bucket.delete hll.key).to be
-        expect{ bucket.get hll.key, type: bucket_type }.to_not raise_error
-
-        expect(bucket.delete hll.key, type: bucket_type).to be
-        expect{ bucket.get hll.key, type: bucket_type }.to raise_error /not_found/
-      end
-    end
-  end
-end

data/spec/integration/riak/conflict_resolution_spec.rb

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