riak-client-noenc 1.0.0

data/spec/integration/yokozuna/schema_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'riak'
+
+describe "Yokozuna", test_client: true, integration: true do
+  before(:all) do
+    @client = test_client
+
+    @index = 'yz_spec-' + random_key
+    @schema = 'yz_spec-' + random_key
+  end
+
+  context 'with no schema' do
+    it 'allows schema creation' do
+      @client.create_search_schema(@schema, SCHEMA_CONTENT)
+      wait_until{ !@client.get_search_schema(@schema).nil? }
+      expect(@client.get_search_schema(@schema)).not_to be_nil
+    end
+  end
+  context 'with a schema' do
+    it 'has a readable schema' do
+      @client.create_search_schema(@schema, SCHEMA_CONTENT)
+      wait_until{ !@client.get_search_schema(@schema).nil? }
+      schema_resp = @client.get_search_schema(@schema)
+      expect(schema_resp.name).to eq(@schema)
+      expect(schema_resp.content).to eq(SCHEMA_CONTENT)
+    end
+  end
+
+  SCHEMA_CONTENT = <<-XML
+<?xml version=\"1.0\" encoding=\"UTF-8\" ?>
+<schema name=\"#{@index}\" 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>
+      XML
+end

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/beefcake_protobuffs_backend/crdt_operator_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+Riak::Client::BeefcakeProtobuffsBackend.configured?
+
+describe Riak::Client::BeefcakeProtobuffsBackend::CrdtOperator do
+
+  let(:backend_class){ Riak::Client::BeefcakeProtobuffsBackend }
+  let(:backend){ double 'beefcake protobuffs backend' }
+  subject { described_class.new backend }
+
+
+  describe 'operating on a counter' do
+    let(:increment){ 5 }
+    let(:operation) do
+      Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :counter
+        op.value = increment
+      end
+    end
+
+    it 'serializes a counter operation into protobuffs' do
+      result = subject.serialize operation
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.counter_op).to be_a backend_class::CounterOp
+      expect(result.counter_op.increment).to eq increment
+    end
+
+    it 'serializes multiple counter operations into protobuffs' do
+      result = subject.serialize [operation, operation]
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.counter_op).to be_a backend_class::CounterOp
+      expect(result.counter_op.increment).to eq (increment * 2)
+    end
+  end
+
+  describe 'operating on a set' do
+    let(:added_element){ 'added_element' }
+    let(:removed_element){ 'removed_element' }
+    let(:operation) do
+      Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :set
+        op.value = {
+          add: [added_element],
+          remove: [removed_element]
+        }
+      end
+    end
+
+    it 'serializes a set operation into protobuffs' do
+      result = subject.serialize operation
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.set_op).to be_a backend_class::SetOp
+      expect(result.set_op.adds).to eq [added_element]
+      expect(result.set_op.removes).to eq [removed_element]
+    end
+  end
+
+  describe 'operating on a map' do
+    it 'serializes inner counter operations' do
+      counter_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_counter'
+        op.type = :counter
+        op.value = 12345
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = counter_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.counter_op).to be_a backend_class::CounterOp
+      expect(map_update.counter_op.increment).to eq 12345
+    end
+
+    it 'serializes inner flag operations' do
+      flag_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_flag'
+        op.type = :flag
+        op.value = true
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = flag_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.flag_op).to eq backend_class::MapUpdate::FlagOp::ENABLE
+
+      flag_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_flag'
+        op.type = :flag
+        op.value = false
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = flag_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.flag_op).to eq backend_class::MapUpdate::FlagOp::DISABLE
+    end
+
+    it 'serializes inner register operations' do
+      register_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_register'
+        op.type = :register
+        op.value = 'hello'
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = register_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.register_op).to eq 'hello'
+
+      delete_op = Riak::Crdt::Operation::Delete.new.tap do |op|
+        op.name = 'inner_register'
+        op.type = :register
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = delete_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{ result.encode }.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_delete = result.map_op.removes.first
+      expect(map_delete).to be_a backend_class::MapField
+      expect(map_delete.name).to eq 'inner_register'
+      expect(map_delete.type).to eq backend_class::MapField::MapFieldType::REGISTER
+    end
+
+    it 'serializes inner set operations' do
+      set_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_set'
+        op.type = :set
+        op.value = {add: 'added_member'}
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = set_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.set_op.adds).to eq 'added_member'
+    end
+
+    it 'serializes inner map operations' do
+      register_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_inner_register'
+        op.type = :register
+        op.value = 'inner_register_value'
+      end
+      inner_map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.name = 'inner_map'
+        op.type = :map
+        op.value = register_op
+      end
+      map_op = Riak::Crdt::Operation::Update.new.tap do |op|
+        op.type = :map
+        op.value = inner_map_op
+      end
+
+      result = subject.serialize map_op
+
+      expect{result.encode}.to_not raise_error
+
+      expect(result).to be_a backend_class::DtOp
+      expect(result.map_op).to be_a backend_class::MapOp
+      map_update = result.map_op.updates.first
+      expect(map_update).to be_a backend_class::MapUpdate
+      expect(map_update.map_op).to be_a backend_class::MapOp
+      expect(map_update.map_op.updates.first.register_op).to eq 'inner_register_value'
+    end
+  end
+end