riak-client 2.1.0 → 2.2.0.pre1

data/spec/riak/beefcake_protobuffs_backend/bucket_properties_operator_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+Riak::Client::BeefcakeProtobuffsBackend.configured?
+
+describe Riak::Client::BeefcakeProtobuffsBackend::BucketPropertiesOperator do
+  let(:backend_class){ Riak::Client::BeefcakeProtobuffsBackend }
+  let(:backend) { instance_double('Riak::Client::BeefcakeProtobuffsBackend') }
+  
+  let(:protocol) do
+    instance_double('Riak::Client::BeefcakeProtobuffsBackend::Protocol').
+      tap do |p|
+      allow(backend).to receive(:protocol).and_yield(p)
+    end
+  end
+
+  let(:bucket_name){ 'bucket_name' }
+  let(:bucket) do
+    instance_double('Riak::Bucket').tap do |b|
+      allow(b).to receive(:name).and_return(bucket_name)
+      allow(b).to receive(:is_a?).with(Riak::Bucket).and_return(true)
+      allow(b).to receive(:needs_type?).and_return(false)
+    end
+  end
+
+  let(:test_props) do
+    backend_class::RpbBucketProps.
+      new(
+          n_val: 3,
+          pr: 0xffffffff - 1,
+          r: 0xffffffff - 2,
+          w: 0xffffffff - 3,
+          pw: 0xffffffff - 4,
+          dw: 0,
+          rw: 1,
+          precommit: precommit,
+          postcommit: backend_class::RpbCommitHook.new(name: 'piper'),
+          linkfun: backend_class::RpbModFun.new(module: 'nachos',
+                                                function: 'galacticos')
+          )
+  end
+
+  let(:precommit) do
+    backend_class::RpbCommitHook.
+      new(
+          modfun: backend_class::RpbModFun.new(
+                                               module: 'validate_json',
+                                               function: 'validate'
+                                               ))
+  end
+
+  let(:get_bucket_request) do
+    backend_class::RpbGetBucketReq.new bucket: bucket_name
+  end
+  
+  let(:get_bucket_response) do
+    backend_class::RpbGetBucketResp.
+      new(props: test_props)
+  end
+
+  let(:get_bucket_expectation) do    
+    expect(protocol).to receive(:write).
+      with(:GetBucketReq, get_bucket_request)
+    
+    expect(protocol).to receive(:expect).
+      with(:GetBucketResp,
+           backend_class::RpbGetBucketResp).
+      and_return(get_bucket_response)
+  end
+
+  subject{ described_class.new backend }
+
+  it 'is initialized with a backend' do
+    expect{ described_class.new backend }.to_not raise_error
+  end
+
+  it 'passes through scalar properties' do
+    get_bucket_expectation
+
+    resp = nil
+    expect{ resp = subject.get bucket }.to_not raise_error
+
+    expect(resp['n_val']).to eq 3
+  end
+
+  describe 'quorums' do
+    it 'rubyfies' do
+      get_bucket_expectation
+
+      resp = nil
+      expect{ resp = subject.get bucket }.to_not raise_error
+
+      expect(resp['pr']).to eq 'one'
+      expect(resp['r']).to eq 'quorum'
+      expect(resp['w']).to eq 'all'
+      expect(resp['pw']).to eq 'default'
+      expect(resp['dw']).to eq 0
+      expect(resp['rw']).to eq 1
+    end
+
+    it 'riakifies' do
+      expected_props = backend_class::RpbBucketProps.
+        new(
+            pr: 0xffffffff - 1,
+            r: 0xffffffff - 2,
+            w: 0xffffffff - 3,
+            pw: 0xffffffff - 4,
+            dw: 0,
+            rw: 1
+            )
+
+      set_bucket_request = backend_class::RpbSetBucketReq.new
+      set_bucket_request.bucket = bucket_name
+      set_bucket_request.props = expected_props
+
+      expect(protocol).to receive(:write).
+        with(:SetBucketReq, set_bucket_request)
+
+      expect(protocol).to receive(:expect).
+        with(:SetBucketResp)
+
+      # support both strings and symbols for quorum names
+      write_props = { 
+        pr: 'one',
+        r: :quorum,
+        w: 'all',
+        pw: :default, 
+        dw: 0,
+        rw: 1
+      }
+
+      expect{ subject.put bucket, write_props }.to_not raise_error
+    end
+  end
+
+  describe 'commit hooks' do
+    it 'rubyfies' do
+      expect(protocol).to receive(:write).
+        with(:GetBucketReq, get_bucket_request)
+      
+      expect(protocol).to receive(:expect).
+        with(:GetBucketResp,
+             backend_class::RpbGetBucketResp).
+        and_return(get_bucket_response)
+
+      resp = nil
+      expect{ resp = subject.get bucket }.to_not raise_error
+
+      expect(resp['precommit']).to be_an Array
+      expect(pre = resp['precommit'].first).to be_a Hash
+      expect(pre['mod']).to eq 'validate_json'
+      expect(pre['fun']).to eq 'validate'
+
+      expect(resp['postcommit'].first).to eq 'piper'
+    end
+
+    it 'riakifies' do
+      modfun = backend_class::RpbModFun.new(
+                                            module: 'validate_json',
+                                            function: 'validate'
+                                            )
+      expected_props = backend_class::RpbBucketProps.
+        new(
+            precommit:  [backend_class::RpbCommitHook.
+                         new(modfun: modfun)],
+            postcommit: [backend_class::RpbCommitHook.
+                         new(name: 'piper')]
+            )
+
+      set_bucket_request = backend_class::RpbSetBucketReq.new
+      set_bucket_request.bucket = bucket_name
+      set_bucket_request.props = expected_props
+
+      expect(protocol).to receive(:write).
+        with(:SetBucketReq, set_bucket_request)
+
+      expect(protocol).to receive(:expect).
+        with(:SetBucketResp)
+
+      write_props = { 
+        precommit: { mod: 'validate_json', fun: 'validate' },
+        postcommit: ['piper']
+      }
+
+      expect{ subject.put bucket, write_props }.to_not raise_error
+    end
+  end
+
+  describe 'modfuns' do
+    it 'rubyfies' do
+      get_bucket_expectation
+
+      resp = nil
+      expect{ resp = subject.get bucket }.to_not raise_error
+
+      expect(resp['linkfun']).to eq({
+                                           'mod' => 'nachos',
+                                           'fun' => 'galacticos'
+                                         })
+
+      expect(resp['chash_keyfun']).to_not be
+    end
+
+    it 'riakifies' do
+      expected_props = backend_class::RpbBucketProps.
+        new(
+            linkfun: backend_class::RpbModFun.new(module: 'nachos',
+                                                  function: 'galacticos')
+            )
+
+      set_bucket_request = backend_class::RpbSetBucketReq.new
+      set_bucket_request.bucket = bucket_name
+      set_bucket_request.props = expected_props
+
+      expect(protocol).to receive(:write).
+        with(:SetBucketReq, set_bucket_request)
+
+      expect(protocol).to receive(:expect).
+        with(:SetBucketResp)
+
+      write_props = { 
+        linkfun: { mod: 'nachos', fun: 'galacticos' }
+      }
+
+      expect{ subject.put bucket, write_props }.to_not raise_error
+    end
+  end
+
+  describe 'repl modes' do
+    it 'riakifies symbols' do
+      expected_props = backend_class::RpbBucketProps.
+        new(repl: 2)
+
+      set_bucket_request = backend_class::RpbSetBucketReq.new
+      set_bucket_request.bucket = bucket_name
+      set_bucket_request.props = expected_props
+
+      expect(protocol).to receive(:write).
+        with(:SetBucketReq, set_bucket_request)
+
+      expect(protocol).to receive(:expect).
+        with(:SetBucketResp)
+
+      write_props = { repl: :fullsync }
+
+      expect{ subject.put bucket, write_props }.to_not raise_error
+    end
+  end
+end

data/spec/riak/bucket_properties_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'riak/bucket_properties'
+
+describe Riak::BucketProperties do
+  let(:client){ instance_double 'Riak::Client' }
+  let(:backend) do
+    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
+      allow(client).to receive(:backend).and_yield be
+    end
+  end
+  
+  let(:props_operator) do
+    instance_double('Riak::Client::BeefcakeProtobuffsBackend::BucketPropertiesOperator').
+      tap do |po|
+      allow(backend).to receive(:bucket_properties_operator).
+        and_return(po)
+    end
+  end
+
+  let(:bucket) do
+    instance_double('Riak::Bucket').tap do |b|
+      allow(b).to receive(:client).and_return(client)
+      allow(b).to receive(:needs_type?).and_return(false)
+    end
+  end
+
+  let(:typed_bucket) do
+    instance_double('Riak::BucketTyped::Bucket').tap do |b|
+      allow(b).to receive(:client).and_return(client)
+    end
+  end
+
+  subject{ described_class.new bucket }
+
+  it 'is initialized with a bucket' do
+    p = nil
+    expect{ p = described_class.new bucket }.to_not raise_error
+    expect(p.client).to eq client
+    expect(p.bucket).to eq bucket
+  end
+
+  it 'initialzies correctly with a bucket-typed bucket' do
+    p = nil
+    expect{ p = described_class.new typed_bucket }.to_not raise_error
+    expect(p.client).to eq client
+    expect(p.bucket).to eq typed_bucket
+  end
+
+  it 'provides hash-like access to properties' do
+    expect(props_operator).to receive(:get).
+      with(bucket).
+      and_return('allow_mult' => true)
+
+    expect(subject['allow_mult']).to be
+
+    subject['allow_mult'] = false
+
+    expect(props_operator).to receive(:put).
+      with(bucket, hash_including('allow_mult' => false))
+
+    subject.store
+  end
+
+  it 'merges properties from hashes' do
+    expect(props_operator).to receive(:get).
+      with(bucket).
+      and_return('allow_mult' => true)
+
+    expect(subject['allow_mult']).to be
+
+    property_hash = { 'allow_mult' => false }
+    expect{ subject.merge! property_hash }.to_not raise_error
+    
+    expect(props_operator).to receive(:put).
+      with(bucket, hash_including('allow_mult' => false))
+
+    subject.store
+  end
+
+  it 'merges properties from other bucket properties objects' do
+    expect(props_operator).to receive(:get).
+      with(bucket).
+      and_return('allow_mult' => true)
+
+    expect(subject['allow_mult']).to be
+
+    other_props = described_class.new typed_bucket
+    other_props.
+      instance_variable_set :@cached_props, { 'allow_mult' => false}
+
+    expect{ subject.merge! other_props }.to_not raise_error
+    
+    expect(props_operator).to receive(:put).
+      with(bucket, hash_including('allow_mult' => false))
+
+    subject.store
+  end
+
+  it 'reloads' do
+    expect(props_operator).to receive(:get).
+      with(bucket).
+      and_return('allow_mult' => true)
+    
+    expect(subject['allow_mult']).to be
+
+    expect(props_operator).to receive(:get).
+      with(bucket).
+      and_return('allow_mult' => false)
+
+    expect{ subject.reload }.to_not raise_error
+
+    expect(subject['allow_mult']).to_not be
+  end
+end

data/spec/riak/bucket_type_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'riak/bucket_type'
+
+describe Riak::BucketType do
+  let(:client){ Riak::Client.allocate }
+  let(:name){ 'bucket_type_spec' }
+  let(:backend) do
+    double('Backend').tap do |backend|
+      allow(client).to receive(:backend).and_yield(backend)
+    end
+  end
+
+  subject{ described_class.new client, name }
+
+  it 'is created with a client and name' do
+    expect{ described_class.new client, name }.to_not raise_error
+  end
+
+  it 'returns a typed bucket' do
+    typed_bucket = subject.bucket 'empanadas'
+    expect(typed_bucket).to be_a Riak::Bucket
+    expect(typed_bucket).to be_a Riak::BucketTyped::Bucket
+    expect(typed_bucket.name).to eq 'empanadas'
+    expect(typed_bucket.type).to eq subject
+  end
+
+  let(:sample_props){ { allow_mult: true } }
+
+  it 'has properties' do
+    expect(backend).to receive(:get_bucket_type_props).with(name).and_return(sample_props)
+    expect(props = subject.properties).to be_a Hash
+    expect(props[:allow_mult]).to be
+  end
+end

data/spec/riak/bucket_typed/bucket.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'riak/bucket_typed/bucket'
+
+describe Riak::BucketTyped::Bucket do
+  let(:client){ Riak::Client.allocate }
+  let(:type){ client.bucket_type 'type' }
+  let(:name){ 'bucket_typed_bucket_spec' }
+
+  subject{ described_class.new client, name, type }
+
+  it 'initializes a typed RObject' do
+    typed_robject = subject.new 'panther'
+    expect(typed_robject).to be_a Riak::RObject
+    expect(typed_robject.key).to eq 'panther'
+    expect(typed_robject.type).to eq type
+  end
+
+  it 'has a bucket type' do
+    expect(subject.type).to eq type
+    expect(subject.type.name).to eq 'type'
+  end
+
+  describe 'bucket properties' do
+    it 'returns properties scoped by bucket and type' do
+      expect(client).to receive(:get_bucket_props).with(subject, { type: subject.type.name }).and_return('allow_mult' => true)
+
+      expect(props = subject.props).to be_a Hash
+      expect(props['allow_mult']).to be
+    end
+
+    it 'clears properties scoped by bucket and type' do
+      expect(client).to receive(:clear_bucket_props).with(subject, { type: subject.type.name })
+
+      expect{ subject.clear_props }.to_not raise_error
+    end
+
+    it 'sets properties scoped by bucket and type' do
+      expect(client).to receive(:set_bucket_props).with(subject, { 'allow_mult' => true }, subject.type.name)
+
+     expect{ subject.props = { 'allow_mult' => true } }.to_not raise_error
+    end
+  end
+end

data/spec/riak/client_spec.rb

@@ -31,10 +31,10 @@ describe Riak::Client, test_client: true do
 
     it "accepts multiple nodes" do
       client = Riak::Client.new :nodes => [
-        {:host => 'riak1.basho.com'},
-        {:host => 'riak2.basho.com', :pb_port => 1234},
-        {:host => 'riak3.basho.com', :pb_port => 5678}
-      ]
+                                           {:host => 'riak1.basho.com'},
+                                           {:host => 'riak2.basho.com', :pb_port => 1234},
+                                           {:host => 'riak3.basho.com', :pb_port => 5678}
+                                          ]
       expect(client.nodes.size).to eq(3)
       expect(client.nodes.first.host).to eq("riak1.basho.com")
     end
@@ -45,6 +45,13 @@ describe Riak::Client, test_client: true do
     expect(subject.stamp).to be_kind_of(Riak::Stamp)
   end
 
+  it 'exposes bucket types' do
+    bucket_type = nil
+    expect{ bucket_type = subject.bucket_type('example') }.to_not raise_error
+    expect(bucket_type).to be_a Riak::BucketType
+    expect(bucket_type.name).to eq 'example'
+  end
+
   describe "reconfiguring" do
     before :each do
       @client = Riak::Client.new
@@ -108,9 +115,9 @@ describe Riak::Client, test_client: true do
       expect(@bucket).to receive(:[]).with('value1').and_return(double('robject'))
       expect(@bucket).to receive(:[]).with('value2').and_return(double('robject'))
       @pairs = [
-        [@bucket, 'value1'],
-        [@bucket, 'value2']
-      ]
+                [@bucket, 'value1'],
+                [@bucket, 'value2']
+               ]
     end
 
     it 'accepts an array of bucket and key pairs' do
@@ -185,7 +192,7 @@ describe Riak::Client, test_client: true do
     end
   end
 
-  describe "when receiving errors from the backend"
+  describe "when receiving errors from the backend" do
     before do
       @client = Riak::Client.new 
     end
@@ -217,4 +224,5 @@ describe Riak::Client, test_client: true do
       expect(error).not_to be_nil
       expect(error).to be_instance_of(RuntimeError)
     end
+  end
 end

data/spec/riak/crdt/counter_spec.rb

@@ -5,7 +5,8 @@ describe Riak::Crdt::Counter do
   let(:bucket) do
     double('bucket').tap do |b|
       allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).and_return(true)
+      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

data/spec/riak/crdt/map_spec.rb

@@ -5,7 +5,8 @@ describe Riak::Crdt::Map do
   let(:bucket) do
     double('bucket').tap do |b|
       allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).and_return(true)
+      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)
       allow(b).to receive(:client).and_return(client)
     end
   end

data/spec/riak/crdt/set_spec.rb

@@ -5,7 +5,8 @@ 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?).and_return(true)
+      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