riak-client 1.4.5 → 2.0.0.rc1

data/spec/integration/yokozuna/index_spec.rb

@@ -0,0 +1,61 @@
+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 "without any indexes" do
+    it "should allow index creation" do
+      expect(@client.create_search_index(@index, "_yz_default", 3)).to eq(true)
+    end
+  end
+
+  context "with an index" do
+    before :all do
+      expect(@client.create_search_index(@index)).to eq(true)
+      wait_until{ !@client.get_search_index(@index).nil? }
+    end
+
+    it "should allow index inspection" do
+      expect(@client.get_search_index(@index).name).to eq(@index)
+      expect{ @client.get_search_index("herp_derp") }.to raise_error(Riak::ProtobuffsFailedRequest)
+    end
+
+    it "should have an index list" do
+      expect(@client.list_search_indexes.size).to be >= 1
+    end
+
+    it "should associate a bucket with an index" do
+      @bucket = Riak::Bucket.new(@client, @index)
+      @bucket.props = {'search_index' => @index}
+      @bucket = @client.bucket(@index)
+      expect(@bucket.props).to include('search_index' => @index)
+    end
+
+    context "associated with a bucket" do
+      before :all do
+        @bucket = Riak::Bucket.new(@client, @index)
+        @bucket.props = {'search_index' => @index}
+        @bucket = @client.bucket(@index)
+        expect(@bucket.props).to include('search_index' => @index)
+      end
+
+      it "should index on object writes" do
+        object = @bucket.get_or_new("cat")
+        object.raw_data = {"cat_s"=>"Lela"}.to_json
+        object.content_type = 'application/json'
+        object.store
+        sleep 1.1  # pause for index commit to trigger
+
+        resp = @client.search(@index, "cat_s:Lela")
+        expect(resp).to include('docs')
+        expect(resp['docs'].size).to eq(1)
+      end
+    end
+  end
+end

data/spec/integration/yokozuna/queries_spec.rb

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'riak'
+
+describe "Yokozuna queries", test_client: true, integration: true do
+  before :all do
+    @client = test_client
+  end
+
+  context "with a schema and indexes" do
+    before :all do
+      @bucket = random_bucket 'yz-spec'
+      @index = @bucket.name
+
+      expect(@client.create_search_index(@index)).to eq(true)
+      wait_until{ !@client.get_search_index(@index).nil? }
+      @client.set_bucket_props(@bucket, {:search_index => @index}, 'yokozuna')
+
+      wait_until do
+        props = @client.get_bucket_props(@bucket, type: 'yokozuna')
+        props['search_index'] == @index
+      end
+
+      @o1 = build_json_obj(@bucket, "cat", {"cat_s"=>"Lela"})
+      @o2 = build_json_obj(@bucket, "docs", {"dog_ss"=>["Einstein", "Olive"]})
+      build_json_obj(@bucket, "Z", {"username_s"=>"Z", "name_s"=>"ryan", "age_i"=>30})
+      build_json_obj(@bucket, "R", {"username_s"=>"R", "name_s"=>"eric", "age_i"=>34})
+      build_json_obj(@bucket, "F", {"username_s"=>"F", "name_s"=>"bryan fink", "age_i"=>32})
+      build_json_obj(@bucket, "H", {"username_s"=>"H", "name_s"=>"brett", "age_i"=>14})
+
+      wait_until { @client.search(@index, "username_s:Z")['docs'].length > 0 }
+    end
+
+    it "should produce results on single term queries" do
+      resp = @client.search(@index, "username_s:Z")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(1)
+    end
+
+    it "should produce results on multiple term queries" do
+      resp = @client.search(@index, "username_s:(F OR H)")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(2)
+    end
+
+    it "should produce results on queries with boolean logic" do
+      resp = @client.search(@index, "username_s:Z AND name_s:ryan")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(1)
+    end
+
+    it "should produce results on range queries" do
+      resp = @client.search(@index, "age_i:[30 TO 33]")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(2)
+    end
+
+    it "should produce results on phrase queries" do
+      resp = @client.search(@index, 'name_s:"bryan fink"')
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(1)
+    end
+
+    it "should produce results on wildcard queries" do
+      resp = @client.search(@index, "name_s:*ryan*")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(2)
+    end
+
+    it "should produce results on regexp queries" do
+      resp = @client.search(@index, "name_s:/br.*/")
+      expect(resp).to include('docs')
+      expect(resp['docs'].size).to eq(2)
+    end
+
+    # TODO: run this when pb utf8 works
+    it "should support utf8" do
+      build_json_obj(@bucket, "ja", {"text_ja"=>"私はハイビスカスを食べるのが 大好き"})
+      # sleep 1.1  # pause for index commit to trigger
+      # resp = @client.search(@index, "text_ja:大好き")
+      # resp.should include('docs')
+      # resp['docs'].size.should == 1
+    end
+
+    context "using parameters" do
+      it "should search one row" do
+        resp = @client.search(@index, "*:*", {:rows => 1})
+        expect(resp).to include('docs')
+        expect(resp['docs'].size).to eq(1)
+      end
+
+      it "should search with df" do
+        resp = @client.search(@index, "Olive", {:rows => 1, :df => 'dog_ss'})
+        expect(resp).to include('docs')
+        expect(resp['docs'].size).to eq(1)
+        resp['docs'].first['dog_ss']
+      end
+
+      it "should produce top result on sort" do
+        resp = @client.search(@index, "username_s:*", {:sort => "age_i asc"})
+        expect(resp).to include('docs')
+        expect(resp['docs'].first['age_i'].to_i).to eq(14)
+      end
+
+    end
+  end
+
+  # populate objects
+  def build_json_obj(bucket, key, data)
+    object = bucket.get_or_new(key)
+    object.raw_data = data.to_json
+    object.content_type = 'application/json'
+    object.store type: 'yokozuna'
+    object
+  end
+end

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 'should allow 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 'should have 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/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 'should serialize 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 'should serialize 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 'should serialize 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 'should serialize 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 'should serialize 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 'should serialize 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 'should serialize 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 'should serialize 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