riak-client 2.5.0 → 2.6.0

data/spec/integration/riak/preflist_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'riak'
-
-describe 'Preflist', integration: true, test_client: true do
-  let(:bucket){ random_bucket }
-  let(:robject) do
-    bucket.get_or_new(random_key).tap do |robj|
-      robj.data = 'asdf'
-      robj.store
-    end
-  end
-
-  matcher :be_a_preflist do
-    match do |actual|
-      actual.is_a?(Array) &&
-      actual.first.is_a?(Riak::PreflistItem)
-    end
-  end
-
-  it 'is available from RObjects' do
-    begin
-      expect(robject.preflist).to be_a_preflist
-    rescue Riak::ProtobuffsErrorResponse
-      skip('preflists are not supported')
-    end
-  end
-
-  it 'is available from Buckets' do
-    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
-    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/properties_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'riak/bucket_properties'
-
-describe Riak::BucketProperties, test_client: true, integration: true do
-  describe 'Bucket Properties objects' do
-    let(:bucket){ random_bucket 'props' }
-    subject{ described_class.new bucket }
-
-    let(:other_bucket) do
-      random_bucket('props-other').tap do |b|
-        p = described_class.new b
-        p['r'] = 1
-        p.store
-      end
-    end
-    let(:other_props){ described_class.new other_bucket }
-
-    before(:example) do
-      bucket.clear_props
-      subject.reload
-    end
-
-    it 'is initializable with a bucket' do
-      expect{ described_class.new bucket }.to_not raise_error
-    end
-
-    it 'works like a hash' do
-      expect(subject['r']).to eq 'quorum'
-      expect{ subject['r'] = 1 }.to_not raise_error
-      subject.store
-      subject.reload
-
-      expect(subject['r']).to eq 1
-    end
-
-    it 'can be merged from a hash' do
-      bulk_props = { r: 1, w: 1, dw: 1 }
-      expect{ subject.merge! bulk_props }.to_not raise_error
-      subject.store
-      subject.reload
-
-      expect(subject['r']).to eq 1
-      expect(subject['w']).to eq 1
-      expect(subject['dw']).to eq 1
-    end
-
-    it 'can be merged from a bucket properties object' do
-      expect(other_props['r']).to eq 1
-      expect(subject['r']).to eq 'quorum'
-
-      expect{ subject.merge! other_props }.to_not raise_error
-      subject.store
-      subject.reload
-
-      expect(subject['r']).to eq 1
-    end
-
-    let(:modfun){ { 'mod' => 'validate_json', 'fun' => 'validate' } }
-
-    it 'works with composite/modfun properties' do
-      expect{ subject['precommit'] = modfun }.to_not raise_error
-
-      subject.store
-      subject.reload
-
-      expect(subject['precommit']).to eq [modfun]
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'timeout'
-
-describe 'Protocol Buffers', test_client: true do
-  describe 'interrupted requests' do
-
-    let(:bucket){ random_bucket 'interrupted_requests' }
-
-    before do
-      first = bucket.new 'first'
-      first.data = 'first'
-      first.content_type = 'text/plain'
-      first.store
-
-      second = bucket.new 'second'
-      second.data = 'second'
-      second.content_type = 'text/plain'
-      second.store
-    end
-
-    it 'fails out when a request is interrupted, and never returns the wrong payload' do
-      expect do
-        Timeout.timeout 1 do
-          loop do
-            expect(bucket.get('first').data).to eq 'first'
-          end
-        end
-      end.to raise_error Timeout::Error
-
-      expect(bucket.get('second').data).to eq 'second'
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-require 'socket'
-require 'spec_helper'
-
-require 'riak/client/beefcake/messages'
-require 'riak/client/beefcake/protocol'
-
-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
-        # unroutable TEST-NET (https://tools.ietf.org/html/rfc5737)
-        config = {}
-        config[:host] = '192.0.2.0'
-        config[:pb_port] = 65535
-
-        config[:connect_timeout] = 0.0001
-        client = Riak::Client.new(config)
-
-        expect do
-          client.ping
-        end.to raise_error RuntimeError, /timed out/
-      end
-
-      it 'raises error on read timeout' do
-        ok_to_continue = false
-        quitting = false
-        port = 0
-
-        server = nil
-        thr = Thread.new do
-          server = TCPServer.new port
-          port = server.addr[1]
-          ok_to_continue = true
-          loop do
-            begin
-              Thread.start(server.accept) do |s|
-                loop do
-                  p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
-                  begin
-                    msgname, _body = p.receive
-                  rescue IOError
-                    break if quitting
-                    raise
-                  end
-                  case msgname
-                  when :PingReq
-                    sleep 0.5
-                    p.write :PingResp
-                  else
-                    $stderr.puts("unknown msgname: #{msgname}")
-                  end
-                end
-              end
-            rescue IOError
-              break if quitting
-              raise
-            end
-          end
-        end
-
-        loop do
-          break if ok_to_continue
-          sleep 0.1
-        end
-        ok_to_continue = false
-
-        config = {}
-        config[:pb_port] = port
-        config[:client_id] = port
-        config[:read_timeout] = 0.0001
-        client = Riak::Client.new(config)
-
-        max_ping_attempts = 16
-        ping_count = 0
-        loop do
-          begin
-            client.ping
-            ping_count += 1
-            break if ping_count > max_ping_attempts
-          rescue RuntimeError => e
-            break if e.message =~ /timed out/
-          end
-          sleep 0.5
-        end
-
-        quitting = true
-        server.close
-        thr.join
-
-        expect(ping_count).to be < max_ping_attempts
-      end
-
-      it 'raises error on write timeout' do
-        ok_to_continue = false
-        quitting = false
-        port = 0
-
-        server = nil
-        thr = Thread.new do
-          server = TCPServer.new port
-          port = server.addr[1]
-          ok_to_continue = true
-          loop do
-            begin
-              Thread.start(server.accept) do |s|
-                loop do
-                  p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
-                  begin
-                    msgname, _body = p.receive
-                  rescue IOError
-                    break if quitting
-                    raise
-                  end
-                  case msgname
-                  when :PingReq
-                    p.write :PingResp
-                  when :GetServerInfoReq
-                    r = Riak::Client::BeefcakeProtobuffsBackend::RpbGetServerInfoResp.new
-                    r.node = 'dev1@127.0.0.1'.force_encoding('BINARY')
-                    r.server_version = '2.1.4'.force_encoding('BINARY')
-                    p.write :GetServerInfoResp, r
-                  when :PutReq
-                    r = Riak::Client::BeefcakeProtobuffsBackend::RpbPutResp.new
-                    p.write :PutResp, r
-                  else
-                    $stderr.puts("unknown msgname: #{msgname}")
-                  end
-                end
-              end
-            rescue IOError
-              break if quitting
-              raise
-            end
-          end
-        end
-
-        loop do
-          break if ok_to_continue
-          sleep 0.1
-        end
-        ok_to_continue = false
-
-        config = {}
-        config[:pb_port] = port
-        config[:client_id] = port
-        config[:write_timeout] = 0.0001
-        client = Riak::Client.new(config)
-
-        bucket = client.bucket('timeouts')
-
-        max_store_attempts = 16
-        store_count = 0
-        loop do
-          begin
-            obj = bucket.new "obj-#{store_count}"
-            # write enough data to grow beyond socket buffer capacity
-            obj.data = SecureRandom.urlsafe_base64(10_000_000)
-            obj.content_type = 'text/plain'
-            obj.store
-            store_count += 1
-            break if store_count > max_store_attempts
-          rescue RuntimeError => e
-            break if e.message =~ /timed out/
-          end
-          sleep 0.5
-        end
-
-        quitting = true
-        server.close
-        thr.join
-
-        expect(store_count).to be < max_store_attempts
-      end
-    end
-  else
-    skip 'not supported in this version of Ruby'
-  end
-end

data/spec/integration/riak/protobuffs_backends_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe "Protocol Buffers", test_client: true do
-  before do
-    @client = test_client
-    @bucket = random_bucket 'protobuf_spec'
-  end
-
-  [:BeefcakeProtobuffsBackend].each do |klass|
-    bklass = Riak::Client.const_get(klass)
-    if bklass.configured?
-      describe klass.to_s do
-        before do
-          @backend = bklass.new(@client, @client.node)
-        end
-
-        it_should_behave_like "Unified backend API"
-
-        describe "searching yokozuna" do
-          include_context "search corpus setup"
-
-          it 'returns 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 do |(k, v)|
-                expect(k.encoding).to eq(utf8)
-                expect(v.encoding).to eq(utf8)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/riak/search_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'riak/search'
-
-describe 'Object-oriented Search API', test_client: true, integration: true, search_config: true do
-  before :all do
-    create_index
-    configure_bucket
-    load_corpus
-  end
-
-  let(:term){ 'bitcask' }
-
-  describe 'queries' do
-    let(:index){ Riak::Search::Index.new test_client, index_name }
-    subject { Riak::Search::Query.new test_client, index, term }
-
-    it 'performs queries' do
-      results = nil
-      expect{ results = subject.results }.to_not raise_error
-      expect(results.raw).to_not be_empty
-      expect(results).to_not be_empty
-    end
-
-    it 'performs limited and sorted queries' do
-      subject.rows = 5
-      results = nil
-      expect{ results = subject.results }.to_not raise_error
-      expect(results.raw).to_not be_empty
-      expect(results.length).to eq 5
-    end
-  end
-
-  describe 'results from queries' do
-    let(:index){ Riak::Search::Index.new test_client, index_name }
-    let(:query){ Riak::Search::Query.new test_client, index, term }
-    subject { query.results }
-
-    it 'exposes search-result documents' do
-      expect(subject).to_not be_empty
-
-      expect(subject.docs).to_not be_empty
-      expect(first = subject.docs.first).to be
-
-      expect(first.score).to be_a Numeric
-
-      expect(first.bucket_type).to be_a Riak::BucketType
-      expect(first.bucket).to be_a Riak::Bucket
-      expect(first.key).to be_a String
-    end
-
-    it 'exposes RObjects' do
-      expect(subject).to_not be_empty
-
-      expect(first = subject.first).to be_a Riak::RObject
-      expect(first).to eq subject.docs.first.robject
-
-      expect(first.key).to eq subject.docs.first.key
-    end
-  end
-
-  describe 'indexes' do
-    it 'tests for index existence and content' do
-      existing_index = Riak::Search::Index.new test_client, index_name
-      expect(existing_index).to be_exists # auto predicate matcher
-
-      nonexistent_index = Riak::Search::Index.new(test_client, "nonexist-#{random_key}")
-      expect(nonexistent_index).to_not be_exists
-    end
-
-    it 'creates indexes' do
-      new_index = Riak::Search::Index.new test_client, "search-spec-#{random_key}"
-      expect(new_index).to_not be_exist
-      expect{ new_index.create! }.to_not raise_error
-
-      wait_until{ new_index.exists? }
-
-      expect(new_index).to be_exists
-
-      expect{ new_index.create! }.to raise_error Riak::SearchError::IndexExistsError
-    end
-  end
-
-  describe 'schemas' do
-    it 'tests for schema existence and content' do
-      existing_schema = Riak::Search::Schema.new test_client, '_yz_default'
-      expect(existing_schema).to be_exists
-
-      nonexistent_schema = Riak::Search::Schema.new(test_client, "nonexist-#{random_key}")
-      expect(nonexistent_schema).to_not be_exists
-    end
-
-    it 'creates schemas' do
-      new_schema = Riak::Search::Schema.new test_client, "search-spec-#{random_key}"
-      expect(new_schema).to_not be_exist
-      expect{ new_schema.create! schema_xml(new_schema.name) }.to_not raise_error
-
-      wait_until{ new_schema.exists? }
-
-      expect(new_schema).to be_exists
-
-      expect{ new_schema.create! schema_xml(new_schema.name) }.to raise_error Riak::SearchError::SchemaExistsError
-    end
-  end
-end