riak-client 2.5.0 → 2.6.0

data/spec/integration/riak/secondary_index_spec.rb

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

@@ -1,105 +0,0 @@
-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
-
-      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
-      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] = '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] = 'riakuser'
-      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,154 +0,0 @@
-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/riak/time_series_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-require 'riak'
-
-describe 'Time Series',
-         test_client: true, integration: true, time_series: true do
-  let(:table_name){ 'GeoCheckin' }
-
-  let(:now_ts) { Time.now.to_i }
-  let(:now){ Time.at(now_ts) }
-  let(:five_minutes_ago){ now - 300 }
-  let(:now_range_str) do
-    past = (now.to_i - 100) * 1000
-    future = (now.to_i + 100) * 1000
-    "time > #{ past } AND time < #{ future }"
-  end
-  let(:never_range_str) do
-    range_start = '1'
-    range_end = '2'
-    "time > #{range_start} AND time < #{range_end}"
-  end
-
-  let(:family){ 'geohash-' + random_key }
-  let(:series){ 'user-' + random_key }
-
-  let(:key){ [family, series, now] }
-  let(:key_ts){ [family, series, now_ts * 1000] }
-  let(:key2){ [family, series, five_minutes_ago] }
-  let(:datum){ [*key, 'cloudy', 27.1] }
-  let(:datum_null){ [*key2, 'cloudy', nil] }
-
-  let(:family_series_str) do
-    "geohash = '#{family}' AND user = '#{series}'"
-  end
-
-  let(:query) do
-    <<-SQL
-SELECT * FROM #{table_name}
-WHERE
-  #{family_series_str} AND
-  #{now_range_str}
-SQL
-  end
-
-  let(:no_data_query) do
-    <<-SQL
-SELECT * FROM #{table_name}
-WHERE
-  #{family_series_str} AND
-  #{never_range_str}
-SQL
-  end
-
-  let(:describe_table) do
-    "DESCRIBE #{table_name}"
-  end
-
-  let(:create_table) do
-    <<-SQL
-CREATE TABLE timeseries-#{random_key} (
-    geohash varchar not null,
-    user varchar not null,
-    time timestamp not null,
-    weather varchar not null,
-    temperature double,
-    PRIMARY KEY(
-        (geohash, user, quantum(time, 15, m)),
-        geohash, user, time
-    )
-)
-SQL
-  end
-
-  let(:stored_datum_expectation) do
-    submission = Riak::TimeSeries::Submission.new test_client, table_name
-    submission.measurements = [datum]
-    expect{ submission.write! }.to_not raise_error
-  end
-
-  let(:stored_datum_null_expectation) do
-    submission = Riak::TimeSeries::Submission.new test_client, table_name
-    submission.measurements = [datum_null]
-    expect{ submission.write! }.to_not raise_error
-  end
-
-  describe 'create table via query' do
-    subject{ Riak::TimeSeries::Query.new test_client, create_table }
-
-    it 'creates a new table without error' do
-      expect{ subject.issue! }.to_not raise_error
-      expect(subject.results).to be
-      expect(subject.results).to be_empty
-    end
-  end
-
-  describe 'describe table via query' do
-    subject{ Riak::TimeSeries::Query.new test_client, describe_table }
-
-    it 'describes a table without error' do
-      expect{ subject.issue! }.to_not raise_error
-      expect(subject.results).to be
-      expect(subject.results).to_not be_empty
-      expect(subject.results.columns).to_not be_empty
-    end
-  end
-
-  describe 'query interface' do
-    subject{ Riak::TimeSeries::Query.new test_client, query }
-    let(:subject_without_data) do
-      Riak::TimeSeries::Query.new test_client, no_data_query
-    end
-
-    it 'queries data without error' do
-      stored_datum_expectation
-
-      expect{ subject.issue! }.to_not raise_error
-      expect(subject.results).to be
-      expect(subject.results).to_not be_empty
-      expect(subject.results.columns).to_not be_empty
-    end
-
-    it 'returns an empty collection when not finding data' do
-      expect{ subject_without_data.issue! }.to_not raise_error
-      expect(subject.results).to_not be
-    end
-  end
-
-  describe 'single-key get interface' do
-    subject{ Riak::TimeSeries::Read.new test_client, table_name }
-    it 'retrieves data without error' do
-      stored_datum_expectation
-
-      subject.key = key
-      result = nil
-      expect{ result = subject.read! }.to_not raise_error
-      expect(result).to be
-      expect(result).to_not be_empty
-      expect(result.first).to_not be_empty
-    end
-
-    it 'retrieves data with a null value without error' do
-      stored_datum_null_expectation
-
-      subject.key = key2
-      result = nil
-      expect{ result = subject.read! }.to_not raise_error
-      expect(result).to be
-      expect(result).to_not be_empty
-
-      row = result.first
-      expect(row).to_not be_empty
-      expect(row[4]).to_not be
-    end
-
-    it 'attempts retrieval of non-existent data without error' do
-      subject.key = [ 'foo', 'bar', now ]
-      result = nil
-      expect{ result = subject.read! }.to_not raise_error
-      expect(result).to_not be
-    end
-  end
-
-  describe 'single-key delete interface' do
-    subject{ Riak::TimeSeries::Deletion.new test_client, table_name }
-    let(:test_read){ Riak::TimeSeries::Read.new test_client, table_name }
-
-    it 'deletes data without error' do
-      stored_datum_expectation
-
-      test_read.key = key
-      expect(test_read.read!).to_not be_empty
-
-      subject.key = key
-      expect{ subject.delete! }.to_not raise_error
-
-      expect(test_read.read!).to_not be
-    end
-  end
-
-  describe 'submission interface' do
-    it 'writes data without error' do
-      stored_datum_expectation
-    end
-    it 'writes data with a null value without error' do
-      stored_datum_null_expectation
-    end
-  end
-
-  describe 'list interface' do
-    it 'passes listed keys to a block' do
-      stored_datum_expectation
-      found_expectation = double 'expectation'
-      expect(found_expectation).to receive(:found!).once
-
-      lister = Riak::TimeSeries::List.new test_client, table_name
-
-      lister.issue! do |row|
-        found_expectation.found! if row.to_a == key_ts
-      end
-    end
-
-    it 'returns a list of keys without a block' do
-      stored_datum_expectation
-      found_expectation = double 'expectation'
-
-      lister = Riak::TimeSeries::List.new test_client, table_name
-
-      results = lister.issue!
-
-      expect(results).to include key_ts
-    end
-  end
-end