riak-client-noenc 1.0.0

data/spec/integration/riak/secondary_index_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'Secondary indexes', test_client: true, integration: true do
+  let(:bucket){ random_bucket '2i-integration' }
+  before do
+    50.times do |i|
+      bucket.new(i.to_s).tap do |obj|
+        obj.indexes["index_int"] << i
+        obj.indexes["index_bin"] << i.to_s
+        obj.data = [i]
+        obj.store
+      end
+    end
+  end
+
+  it "finds keys for an equality query" do
+    expect(bucket.get_index('index_int', 20)).to eq(["20"])
+  end
+
+  it "finds keys for a range query" do
+    expect(bucket.get_index('index_int', 19..21)).to match_array(%w(19 20 21))
+  end
+
+  it "returns an empty array for a query that does not match any keys" do
+    expect(bucket.get_index('index_int', 10000)).to eq([])
+  end
+
+  it "returns terms" do
+    results = nil
+    expect do
+      results = bucket.get_index('index_int',
+                                 19..21,
+                                 return_terms: true)
+    end.to_not raise_error
+
+    expect(results).to be_a Array
+    expect(results.with_terms).to be_a Hash
+  end
+
+  it "returns terms matching a term_regex" do
+    results = nil
+    expect do
+      results = bucket.get_index('index_bin',
+                                 '19'..'21',
+                                 return_terms: true,
+                                 term_regex: '20')
+    end.to_not raise_error
+
+    terms = results.with_terms
+
+    expect(terms['20']).to be
+    expect(terms['19']).to be_empty
+  end
+
+  describe "with symbolized index names" do
+    it "stores and queries indexes correctly" do
+      obj = bucket.new random_key
+      obj.indexes[:coat_pattern_bin] << "tuxedo"
+      obj.data = "tuxedo"
+
+      expect{ obj.store }.to_not raise_error
+
+      results = nil
+      expect do
+        results = bucket.get_index(:coat_pattern_bin,
+                                   'tuxedo')
+      end.to_not raise_error
+
+      expect(results.first).to eq obj.key
+    end
+  end
+end

data/spec/integration/riak/security_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'riak'
+require 'riak/errors/connection_error'
+require 'cert_validator/errors'
+
+describe 'Secure Protobuffs', test_client: true, integration: true do
+  let(:config){ test_client_configuration.dup }
+  describe 'without security enabled on Riak', no_security: true do
+    it 'connects normally without authentication configured' do
+      expect(test_client.security?).to_not be
+
+      expect{test_client.ping}.to_not raise_error
+    end
+
+    it 'refuses to connect with authentication configured' do
+      with_auth_config = config.dup
+      with_auth_config[:authentication] = { user: 'user', password: 'password' }
+
+      secure_client = Riak::Client.new with_auth_config
+
+      expect{ secure_client.ping }.to raise_error(Riak::TlsError)
+    end
+  end
+
+  describe 'with security enabled on Riak', yes_security: true do
+    it 'connects normally with authentication configured' do
+      secure_client = Riak::Client.new config
+
+      expect(secure_client.security?).to be
+
+      expect{secure_client.ping}.to_not raise_error
+    end
+
+    it 'refuses to connect without authentication configured' do
+      no_auth_config = config.dup
+      no_auth_config.delete :authentication
+
+      plaintext_client = Riak::Client.new no_auth_config
+
+      expect{ plaintext_client.ping }.
+        to(raise_error(Riak::ProtobuffsFailedRequest,
+                       /security is enabled/i))
+    end
+
+    it "refuses to connect if the server cert isn't recognized" do
+      broken_auth_config = config.dup
+      broken_auth_config[:authentication] = broken_auth_config[:authentication].dup
+      # this CA has never ever been used to sign a key
+      broken_auth_config[:authentication][:ca_file] =
+        File.join('support', 'certs', 'empty_ca.crt')
+
+      bugged_crypto_client = Riak::Client.new broken_auth_config
+
+      expect{ bugged_crypto_client.ping }.
+        to(raise_error(OpenSSL::SSL::SSLError,
+                       /certificate verify failed/i))
+    end
+
+    it "refuses to connect if the server cert is revoked" do
+      revoked_auth_config = config.dup
+      revoked_auth_config[:authentication] = revoked_auth_config[:authentication].dup
+
+      revoked_auth_config[:authentication][:crl_file] =
+        File.expand_path(File.join('..',
+                                   '..',
+                                   '..',
+                                   'support',
+                                   'certs',
+                                   'server.crl'),
+                         __FILE__)
+      revoked_auth_config[:authentication][:crl] = true
+
+      revoked_auth_client = Riak::Client.new revoked_auth_config
+
+      expect{ revoked_auth_client.ping }.
+        to(raise_error(Riak::TlsError,
+                       /revoked/i))
+    end
+  end
+
+  describe 'with client certificate security enabled on Riak', yes_security: true do
+    it 'connects normally with authentication configured' do
+      client_cert_config = config.dup
+      client_cert_config[:authentication] =
+        client_cert_config[:authentication].dup
+
+      client_cert_config[:authentication][:client_ca] = client_cert_config[:authentication]['ca_file']
+
+      client_cert_config[:authentication][:cert] = 'spec/support/certs/client.crt'
+      client_cert_config[:authentication][:key] = 'spec/support/certs/client.key'
+
+      client_cert_config[:authentication][:user] = 'certuser'
+      client_cert_config[:authentication][:password] = ''
+
+      cert_client = Riak::Client.new client_cert_config
+
+      expect{ cert_client.ping }.to_not raise_error
+    end
+  end
+end

data/spec/integration/riak/threading_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe "Multithreaded client", :test_client => true do
+  class Synchronizer
+    def initialize(n)
+      @mutex = Mutex.new
+      @n = n
+      @waiting = Set.new
+    end
+
+    def sync
+      stop = false
+      @mutex.synchronize do
+        @waiting << Thread.current
+
+        if @waiting.size >= @n
+          # All threads are waiting.
+          @waiting.each do |t|
+            t.run
+          end
+        else
+          stop = true
+        end
+      end
+
+      if stop
+        Thread.stop
+      end
+    end
+  end
+
+  def threads(n, opts = {})
+    if opts[:synchronize]
+      s1 = Synchronizer.new n
+      s2 = Synchronizer.new n
+    end
+
+    threads = (0...n).map do |i|
+      Thread.new do
+        if opts[:synchronize]
+          s1.sync
+        end
+
+        yield i
+
+        if opts[:synchronize]
+          s2.sync
+        end
+      end
+    end
+
+    threads.each do |t|
+      t.join
+    end
+  end
+
+  [
+   {:protobuffs_backend => :Beefcake}
+  ].each do |opts|
+    describe opts.inspect do
+      before do
+        @bucket = random_bucket 'threading'
+      end
+
+      it 'gets in parallel' do
+        data = "the gun is good"
+        ro = @bucket.new('test')
+        ro.content_type = "application/json"
+        ro.data = [data]
+        ro.store
+
+        threads 10, :synchronize => true do
+          x = @bucket['test']
+          expect(x.content_type).to eq("application/json")
+          expect(x.data).to eq([data])
+        end
+      end
+
+      it 'puts in parallel' do
+        data = "the tabernacle is indestructible and everlasting"
+
+        n = 10
+        threads n, :synchronize => true do |i|
+          x = @bucket.new("test-#{i}")
+          x.content_type = "application/json"
+          x.data = ["#{data}-#{i}"]
+          x.store
+        end
+
+        (0...n).each do |i|
+          read = @bucket["test-#{i}"]
+          expect(read.content_type).to eq("application/json")
+          expect(read.data).to eq(["#{data}-#{i}"])
+        end
+      end
+
+      # This is a 1.0+ spec because putting with the same client ID
+      # will not create siblings on 0.14 in the same way. This will
+      # also likely fail for nodes with vnode_vclocks = false.
+      it 'puts conflicts in parallel' do
+        @bucket.allow_mult = true
+        expect(@bucket.allow_mult).to eq(true)
+
+        init = @bucket.new('test')
+        init.content_type = "application/json"
+        init.data = ''
+        init.store
+
+        # Create conflicting writes
+        n = 10
+        s = Synchronizer.new n
+        threads n, :synchronize => true do |i|
+          x = @bucket["test"]
+          s.sync
+          x.data = [i]
+          x.store
+        end
+
+        read = @bucket["test"]
+        expect(read.conflict?).to eq(true)
+        expect(read.siblings.map do |sibling|
+          sibling.data.first
+        end.to_set).to eq((0...n).to_set)
+      end
+
+      it 'lists-keys and gets in parallel', :slow => true do
+        count = 100
+        threads = 2
+
+        # Create items
+        count.times do |i|
+          o = @bucket.new("#{i}")
+          o.content_type = 'application/json'
+          o.data = [i]
+          o.store
+        end
+
+        threads(threads) do
+          set = Set.new
+          @bucket.keys do |stream|
+            stream.each do |key|
+              set.merge @bucket[key].data
+            end
+          end
+          expect(set).to eq((0...count).to_set)
+        end
+      end
+    end
+  end
+end

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 "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 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,115 @@
+# 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 1.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