riak-client 2.5.0 → 2.6.0

data/spec/integration/yokozuna/index_spec.rb

@@ -1,61 +0,0 @@
-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 "allows 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 "allows 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 "has an index list" do
-      expect(@client.list_search_indexes.size).to be >= 1
-    end
-
-    it "associates 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 "indexes 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 2.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

@@ -1,115 +0,0 @@
-# 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"=>%w(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 "produces 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 "produces 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 "produces 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 "produces 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 "produces 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 "produces 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 "produces 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
-
-    it "supports utf8" do
-      build_json_obj(@bucket, "ja", {"text_ja"=>"私はハイビスカスを食べるのが 大好き"})
-      sleep 2.1  # pause for index commit to trigger
-      resp = @client.search(@index, "text_ja:大好き")
-      expect(resp).to include('docs')
-      expect(resp['docs'].size).to eq 1
-    end
-
-    context "using parameters" do
-      it "searches one row" do
-        resp = @client.search(@index, "*:*", {:rows => 1})
-        expect(resp).to include('docs')
-        expect(resp['docs'].size).to eq(1)
-      end
-
-      it "searches 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 "produces 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

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

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