riak-client 2.4.1 → 2.5.0

data/spec/integration/riak/encodings/yz_spec.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 require 'spec_helper'
 require 'riak'
+require 'riak/util/string'
 
 describe 'Encoding and Riak Search', integration: true, search_config: true do
   let(:bucket_type){ test_client.bucket_type 'yokozuna' }
@@ -72,7 +73,7 @@ EOD
       expect(results).to_not be_empty
       expect(results.docs.first.bucket_type).to eq robj.bucket.type
       expect(results.docs.first.bucket).to eq robj.bucket
-      expect(results.docs.first.key.bytes).to eq robj.key.bytes
+      expect(Riak::Util::String.equal_bytes?(results.docs.first.key, robj.key)).to be
     end
   end
 

data/spec/integration/riak/preflist_spec.rb

@@ -18,14 +18,26 @@ describe 'Preflist', integration: true, test_client: true do
   end
 
   it 'is available from RObjects' do
-    expect(robject.preflist).to be_a_preflist
+    begin
+      expect(robject.preflist).to be_a_preflist
+    rescue Riak::ProtobuffsErrorResponse
+      skip('preflists are not supported')
+    end
   end
 
   it 'is available from Buckets' do
-    expect(bucket.get_preflist robject.key).to be_a_preflist
+    begin
+      expect(bucket.get_preflist robject.key).to be_a_preflist
+    rescue Riak::ProtobuffsErrorResponse
+      skip('preflists are not supported')
+    end
   end
 
   it 'is available from the Client' do
-    expect(test_client.get_preflist bucket.name, robject.key).to be_a_preflist
+    begin
+      expect(test_client.get_preflist bucket.name, robject.key).to be_a_preflist
+    rescue Riak::ProtobuffsErrorResponse
+      skip('preflists are not supported')
+    end
   end
 end

data/spec/integration/riak/protobuffs/timeouts_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 require 'riak/client/beefcake/messages'
 require 'riak/client/beefcake/protocol'
 
-describe 'Protocol Buffers', test_client: true, integration: true do
+describe 'Protocol Buffers', test_client: true, integration: true, slow: true do
   if RUBY_VERSION >= '2.0.0'
     describe 'timeouts' do
       it 'raises error on connect timeout' do

data/spec/integration/riak/security_spec.rb

@@ -51,9 +51,14 @@ describe 'Secure Protobuffs', test_client: true, integration: true do
 
       bugged_crypto_client = Riak::Client.new broken_auth_config
 
-      expect{ bugged_crypto_client.ping }.
-        to(raise_error(OpenSSL::SSL::SSLError,
-                       /certificate verify failed/i))
+      if RUBY_PLATFORM == 'java'
+        expect{ bugged_crypto_client.ping }.
+          to(raise_error(OpenSSL::SSL::SSLError))
+      else
+        expect{ bugged_crypto_client.ping }.
+          to(raise_error(OpenSSL::SSL::SSLError,
+                         /certificate verify failed/i))
+      end
     end
 
     it "refuses to connect if the server cert is revoked" do
@@ -86,10 +91,10 @@ describe 'Secure Protobuffs', test_client: true, integration: true do
 
       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][:cert] = 'tools/test-ca/certs/riakuser-client-cert.pem'
+      client_cert_config[:authentication][:key] = 'tools/test-ca/private/riakuser-client-cert-key.pem'
 
-      client_cert_config[:authentication][:user] = 'certuser'
+      client_cert_config[:authentication][:user] = 'riakuser'
       client_cert_config[:authentication][:password] = ''
 
       cert_client = Riak::Client.new client_cert_config

data/spec/integration/riak/threading_spec.rb

@@ -1,150 +1,154 @@
-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
+require 'spec_helper'
+
+describe "Multithreaded client", :test_client => true do
+  if ENV['TRAVIS'] == 'true' && RUBY_PLATFORM == 'java'
+    skip 'multithreaded client tests time out on Travis CI'
+    break
+  end
+  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

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