riak-client 1.4.5 → 2.0.0.rc1

data/spec/integration/riak/crdt_validation/map_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'riak'
+
+describe 'CRDT map validation', integration: true, test_client: true do
+  let(:bucket){ random_bucket 'crdt_validation' }
+  let(:map){ Riak::Crdt::Map.new bucket, random_key }
+
+  it 'deletes sets and re-add entries' do
+    map.batch do |m|
+      m.sets['set'].add 'X'
+      m.sets['set'].add 'Y'
+    end
+
+    map.reload
+    expect(map.sets['set'].include? 'Y').to be
+
+    expect do
+      map.batch do |m|
+        m.sets.delete 'set'
+        m.sets['set'].add 'Z'
+      end
+    end.to_not raise_error
+
+    map2 = Riak::Crdt::Map.new bucket, map.key
+    
+    expect(map2.sets['set'].members).to eq ::Set.new(['Z'])
+  end
+
+  it 'deletes counters and increments counters' do
+    map.counters['counter'].increment 5
+
+    map.reload
+    
+    expect(map.counters['counter'].value).to eq 5
+
+    map.batch do |m|
+      m.counters['counter'].increment 2
+      m.counters.delete 'counter'
+    end
+
+    map2 = Riak::Crdt::Map.new bucket, map.key
+
+    expect(map2.counters['counter'].value).to eq(7).or eq(2)
+  end
+
+  it 'deletes maps containing sets and re-adds the contained sets' do
+    map.batch do |m|
+      m.maps['map'].sets['set'].add "X"
+      m.maps['map'].sets['set'].add "Y"
+    end
+
+    map.reload
+    expect(map.maps['map'].sets['set'].members).to eq ::Set.new(['X', 'Y'])
+
+    map.batch do |m|
+      m.maps.delete 'map'
+      m.maps['map'].sets['set'].add "Z"
+    end
+    
+    map2 = Riak::Crdt::Map.new bucket, map.key
+    expect(map2.maps['map'].sets['set'].members).to eq ::Set.new(['Z'])
+  end
+end

data/spec/integration/riak/crdt_validation/set_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'riak'
+
+describe 'CRDT set validation', integration: true, test_client: true do
+  let(:bucket){ random_bucket 'crdt_validation' }
+  let(:set){ Riak::Crdt::Set.new bucket, random_key }
+  
+  it 'removes recently-added set entries during batch mode' do
+    expect do
+      set.batch do |s|
+        s.add 'X'
+        s.add 'Y'
+        s.add 'Z'
+        s.remove 'Y'
+      end
+    end.to raise_error Riak::CrdtError::SetRemovalWithoutContextError
+  end
+  
+  it 'removes non-members with context' do
+    set.batch do |s|
+      s.add 'X'
+      s.add 'Y'
+    end
+    
+    set.reload
+    
+    expect{ set.remove 'bogus' }.to_not raise_error
+    
+    set2 = Riak::Crdt::Set.new bucket, set.key
+    expect(set2.members).to eq ::Set.new(%w{X Y})
+  end
+
+  it 'adds duplicate members' do
+    set.batch do |s|
+      s.add 'X'
+      s.add 'Y'
+    end
+    
+    set.reload
+    
+    expect{ set.add 'X' }.to_not raise_error
+
+    set2 = Riak::Crdt::Set.new bucket, set.key
+    expect(set2.members).to eq ::Set.new(%w{X Y})
+  end
+
+  it 'no-ops adding then removing a duplicate member' do
+    set.batch do |s|
+      s.add 'X'
+      s.add 'Y'
+    end
+
+    set.reload
+    expect(set.members).to eq ::Set.new(%w{X Y})
+
+    expect do
+      set.batch do |s|
+        s.add 'X'
+        s.remove 'X'
+      end
+    end.to_not raise_error
+
+    set2 = Riak::Crdt::Set.new bucket, set.key
+    expect(set2.members).to eq ::Set.new(%w{X Y})
+  end
+
+  it 'no-ops removing then re-adding a set member' do
+    set.batch do |s|
+      s.add 'X'
+      s.add 'Y'
+    end
+
+    set.reload
+    expect(set.members).to eq ::Set.new(%w{X Y})
+
+    expect do
+      set.batch do |s|
+        s.remove 'X'
+        s.add 'X'
+      end
+    end.to_not raise_error
+
+    set2 = Riak::Crdt::Set.new bucket, set.key
+    expect(set2.members).to eq ::Set.new(%w{X Y})
+  end
+
+  describe 'parallel operations' do
+    it 'removes with up-to-date context' do
+      set.batch do |s|
+        s.add 'X'
+        s.add 'Y'
+      end
+      
+      set_parallel = Riak::Crdt::Set.new bucket, set.key
+      set_parallel.add 'Z'
+      
+      set.reload
+      
+      expect{ set.remove 'Z' }.to_not raise_error
+      
+      set2 = Riak::Crdt::Set.new bucket, set.key
+      expect(set2.members).to eq ::Set.new(%w{X Y})
+    end
+
+    it "doesn't remove with outdated context" do
+      set.batch do |s|
+        s.add 'X'
+        s.add 'Y'
+      end
+      
+      set.reload
+      
+      set_parallel = Riak::Crdt::Set.new bucket, set.key
+      set_parallel.add 'Z'
+
+      expect{ set.remove 'Z' }.to_not raise_error
+
+      set2 = Riak::Crdt::Set.new bucket, set.key
+      expect(set2.members).to eq ::Set.new(%w{X Y Z})
+    end
+  end
+end

data/spec/integration/riak/protobuffs_backends_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
-describe "Protocol Buffers" do
+describe "Protocol Buffers", test_client: true do
   before do
-    @pbc_port ||= test_server.pb_port
-    @http_port ||= test_server.http_port
-    @client = Riak::Client.new(:http_port => @http_port, :pb_port => @pbc_port, :protocol => "pbc")
+    @client = test_client
+    @bucket = random_bucket 'protobuf_spec'
   end
 
   [:BeefcakeProtobuffsBackend].each do |klass|
@@ -17,30 +16,14 @@ describe "Protocol Buffers" do
 
         it_should_behave_like "Unified backend API"
 
-        describe "searching fulltext indexes (1.1 and earlier)", :version => '< 1.2.0' do
+        describe "searching yokozuna" do
           include_context "search corpus setup"
 
-          it 'should find document IDs via MapReduce' do
-            # Note that the trailing options Hash is ignored when
-            # emulating search with MapReduce
-            results = @backend.search 'search_test', 'fearless elephant rushed'
-            results.should have_key 'docs'
-            results.should have_key 'max_score'
-            results.should have_key 'num_found'
-            results['docs'].should include({"id" => "munchausen-605"})
-          end
-        end
-
-        if "".respond_to?(:encoding) # Ruby 1.9 and later only
-          describe "searching fulltext indexes (1.2 and later)", :version => '>= 1.2.0' do
-            include_context "search corpus setup"
-
-            it 'should return documents with UTF-8 fields (GH #75)' do
-              utf8 = Encoding.find('UTF-8')
-              results = @backend.search 'search_test', 'fearless elephant rushed'
-              results['docs'].each do |d|
-                d.each {|(k,v)| k.encoding.should == utf8; v.encoding.should == utf8 }
-              end
+          it 'should return documents with UTF-8 fields (GH #75)' do
+            utf8 = Encoding.find('UTF-8')
+            results = @backend.search @search_bucket.name, 'fearless elephant rushed', df: 'text'
+            results['docs'].each do |d|
+              d.each {|(k,v)| expect(k.encoding).to eq(utf8); expect(v.encoding).to eq(utf8) }
             end
           end
         end

data/spec/integration/riak/security_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'riak'
+require 'riak/errors/connection_error'
+require 'r509/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(__dir__, '..', '..', 'support', 'certs', 'server.crl'))
+      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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Multithreaded client", :test_server => true do
+describe "Multithreaded client", :test_client => true do
   class Synchronizer
     def initialize(n)
       @mutex = Mutex.new
@@ -55,31 +55,24 @@ describe "Multithreaded client", :test_server => true do
   end
 
   [
-   {:protocol => 'pbc', :protobuffs_backend => :Beefcake},
-   {:protocol => 'http', :http_backend => :NetHTTP},
-   {:protocol => 'http', :http_backend => :Excon}
+   {:protobuffs_backend => :Beefcake}
   ].each do |opts|
     describe opts.inspect do
       before do
-        @pb_port ||= test_server.pb_port
-        @http_port ||= test_server.http_port
-        @client = Riak::Client.new({
-                                     :pb_port => @pb_port,
-                                     :http_port => @http_port
-                                   }.merge(opts))
+        @bucket = random_bucket 'threading'
       end
 
       it 'should get in parallel' do
         data = "the gun is good"
-        ro = @client['test'].new('test')
+        ro = @bucket.new('test')
         ro.content_type = "application/json"
         ro.data = [data]
         ro.store
 
         threads 10, :synchronize => true do
-          x = @client['test']['test']
-          x.content_type.should == "application/json"
-          x.data.should == [data]
+          x = @bucket['test']
+          expect(x.content_type).to eq("application/json")
+          expect(x.data).to eq([data])
         end
       end
 
@@ -88,27 +81,27 @@ describe "Multithreaded client", :test_server => true do
 
         n = 10
         threads n, :synchronize => true do |i|
-          x = @client['test'].new("test-#{i}")
+          x = @bucket.new("test-#{i}")
           x.content_type = "application/json"
           x.data = ["#{data}-#{i}"]
           x.store
         end
 
         (0...n).each do |i|
-          read = @client['test']["test-#{i}"]
-          read.content_type.should == "application/json"
-          read.data.should == ["#{data}-#{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 'should put conflicts in parallel', :version => ">= 1.0.0" do
-        @client['test'].allow_mult = true
-        @client['test'].allow_mult.should == true
+      it 'should put conflicts in parallel' do
+        @bucket.allow_mult = true
+        expect(@bucket.allow_mult).to eq(true)
 
-        init = @client['test'].new('test')
+        init = @bucket.new('test')
         init.content_type = "application/json"
         init.data = ''
         init.store
@@ -117,17 +110,17 @@ describe "Multithreaded client", :test_server => true do
         n = 10
         s = Synchronizer.new n
         threads n, :synchronize => true do |i|
-          x = @client['test']["test"]
+          x = @bucket["test"]
           s.sync
           x.data = [i]
           x.store
         end
 
-        read = @client['test']["test"]
-        read.conflict?.should == true
-        read.siblings.map do |sibling|
+        read = @bucket["test"]
+        expect(read.conflict?).to eq(true)
+        expect(read.siblings.map do |sibling|
           sibling.data.first
-        end.to_set.should == (0...n).to_set
+        end.to_set).to eq((0...n).to_set)
       end
 
       it 'should list-keys and get in parallel', :slow => true do
@@ -136,7 +129,7 @@ describe "Multithreaded client", :test_server => true do
 
         # Create items
         count.times do |i|
-          o = @client['test'].new("#{i}")
+          o = @bucket.new("#{i}")
           o.content_type = 'application/json'
           o.data = [i]
           o.store
@@ -144,48 +137,12 @@ describe "Multithreaded client", :test_server => true do
 
         threads(threads) do
           set = Set.new
-          @client['test'].keys do |stream|
+          @bucket.keys do |stream|
             stream.each do |key|
-              set.merge @client['test'][key].data
+              set.merge @bucket[key].data
             end
           end
-          set.should == (0...count).to_set
-        end
-      end
-
-      sometimes 'should mapreduce in parallel' do
-        if ("1.0.0"..."1.1.0").include?(test_server.version)
-          # On a fresh node, this module might not have been loaded yet
-          # and the mapred test exposes a race condition in riak_pipe_v
-          # when verifying function validity. This race condition is
-          # fixed in 1.1.
-          test_server.with_console do |console|
-            console.command 'code:load(riak_kv_pipe_get), ok.'
-            console.command 'code:load(riak_kv_mrc_map), ok.'
-          end
-        end
-
-        count = 10
-        threads = 10
-
-        # Create items
-        count.times do |i|
-          o = @client['test'].new("#{i}")
-          o.content_type = 'application/json'
-          o.data = i
-          o.store
-        end
-
-        # Ze mapreduce
-        threads(threads) do
-          # Mapreduce
-          (0...count).inject(Riak::MapReduce.new(@client)) do |mr, i|
-            mr.add('test', i.to_s)
-          end.map(%{function(v) {
-            return [v.key];
-          }}, :keep => true).run.map do |s|
-            s.to_i
-          end.to_set.should == (0...count).to_set
+          expect(set).to eq((0...count).to_set)
         end
       end
     end