riak-client 2.5.0 → 2.6.0

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

@@ -1,63 +0,0 @@
-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(%w(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

@@ -1,122 +0,0 @@
-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/encodings/crdt_spec.rb

@@ -1,122 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'riak'
-require 'riak/util/string'
-
-describe 'Encoding and CRDTs', integration: true, search_config: true do
-  shared_examples 'CRDTs with weird names' do
-    let(:counter_bucket) do
-      test_client.bucket_type(Riak::Crdt::DEFAULT_BUCKET_TYPES[:counter]).bucket(random_string)
-    end
-    let(:map_bucket) do
-      test_client.bucket_type(Riak::Crdt::DEFAULT_BUCKET_TYPES[:map]).bucket(random_string)
-    end
-    let(:set_bucket) do
-      test_client.bucket_type(Riak::Crdt::DEFAULT_BUCKET_TYPES[:set]).bucket(random_string)
-    end
-    let(:hll_bucket) do
-      test_client.bucket_type(Riak::Crdt::DEFAULT_BUCKET_TYPES[:hll]).bucket(random_string)
-    end
-
-    it 'creates counters' do
-      counter = nil
-
-      expect{ counter = Riak::Crdt::Counter.new counter_bucket, random_string }.
-        to_not raise_error
-
-      expect(counter).to be_a Riak::Crdt::Counter
-
-      expect(value = counter.value).to be_a Numeric
-
-      expect{ counter.increment }.to_not raise_error
-
-      expect(counter.value).to eq value + 1
-    end
-
-    it 'updates registers in maps' do
-      map = nil
-
-      expect(random_string.encoding.name).to eq expected_encoding
-
-      expect{ map = Riak::Crdt::Map.new map_bucket, random_string }.
-        to_not raise_error
-
-      expect(map).to be_a Riak::Crdt::Map
-
-      expect(map.registers[random_string]).to be_nil
-
-      expect{ map.registers[random_string] = random_string }.
-        to_not raise_error
-
-      expect(map.registers.length).to eq 1
-
-      expect(map.registers[random_string]).to_not be_nil
-
-      expect(Riak::Util::String.equal_bytes?(map.registers[random_string], random_string)).to be
-
-      expect(random_string.encoding.name).to eq expected_encoding
-    end
-
-    it 'updates sets' do
-      set = nil
-
-      expect(random_string.encoding.name).to eq expected_encoding
-
-      expect{ set = Riak::Crdt::Set.new set_bucket, random_string }.
-        to_not raise_error
-
-      expect(set).to be_a Riak::Crdt::Set
-
-      expect(set.include?(random_string)).to_not be
-
-      set.add random_string
-
-      expect(set.include?(random_string)).to be
-
-      set.remove random_string
-
-      expect(set.include?(random_string)).to_not be
-
-      expect(random_string.encoding.name).to eq expected_encoding
-    end
-
-    it 'updates hyper_log_logs', hll: true do
-      begin
-        hlls = test_client.bucket_type Riak::Crdt::DEFAULT_BUCKET_TYPES[:hll]
-        hlls.properties
-      rescue Riak::ProtobuffsErrorResponse
-        skip('HyperLogLog bucket-type not found or active.')
-      end
-
-      hll = nil
-
-      expect(random_string.encoding.name).to eq expected_encoding
-
-      expect{ hll = Riak::Crdt::HyperLogLog.new hll_bucket, random_string }.to_not raise_error
-      expect(hll).to be_a Riak::Crdt::HyperLogLog
-
-      hll.add random_string
-
-      expect(hll.value).to be_a(Integer)
-      expect(hll.value).to eq 1
-
-      expect(random_string.encoding.name).to eq expected_encoding
-    end
-  end
-
-  describe 'with utf-8 strings' do
-    let(:string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
-    let(:expected_encoding){ 'UTF-8' }
-    let(:random_string){ string + random_key }
-
-    include_examples 'CRDTs with weird names'
-  end
-
-  describe 'with binary strings' do
-    let(:string){ "\xff\xff".force_encoding('binary') }
-    let(:expected_encoding){ 'ASCII-8BIT' }
-    let(:random_string){ string + random_key }
-
-    include_examples 'CRDTs with weird names'
-  end
-end

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

@@ -1,87 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'riak'
-
-describe 'Encoding and Riak KV', integration: true, test_client: true do
-  let(:bucket_type){ test_client.bucket_type 'yokozuna' }
-
-  let(:utf8_encoding){ Encoding.find 'utf-8' }
-  let(:utf8_string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
-  let(:random_utf8_string){ utf8_string + random_key }
-  let(:utf8_bucket){ bucket_type.bucket random_utf8_string }
-
-  let(:binary_encoding){ Encoding.find 'binary' }
-  let(:binary_string){ "\xff\xff".force_encoding('binary') }
-  let(:random_binary_string){ binary_string + random_key }
-  let(:binary_bucket){ bucket_type.bucket random_binary_string }
-
-  it 'encodes the test strings correctly' do
-    expect(utf8_string.encoding).to eq utf8_encoding
-    expect(random_utf8_string.encoding).to eq utf8_encoding
-    expect(binary_string.encoding).to eq binary_encoding
-    expect(random_binary_string.encoding).to eq binary_encoding
-  end
-
-  describe 'key-value operations' do
-    it 'allows utf-8 strings in bucket and key names, values, and 2i' do
-      expect(utf8_bucket).to be_a Riak::Bucket
-      expect(robj = utf8_bucket.new(random_utf8_string)).to be_a Riak::RObject
-      robj.content_type = 'text/plain'
-      robj.data = random_utf8_string
-      robj.indexes['cat_bin'] = [random_utf8_string, 'asdf']
-      expect{ robj.store }.to_not raise_error
-
-      expect(robj2 = utf8_bucket.get(random_utf8_string)).to be_a Riak::RObject
-      expect(robj2.data).to eq random_utf8_string
-
-      robj.raw_data = random_utf8_string
-      robj.store
-      robj2.reload
-      expect(robj2.raw_data).to eq random_utf8_string
-      expect(robj2.indexes['cat_bin']).to include 'asdf'
-      expect(robj2.indexes['cat_bin']).
-        to include random_utf8_string.force_encoding('binary')
-
-      expect(utf8_bucket.get_index 'cat_bin', 'asdf').
-        to include random_utf8_string.force_encoding('binary')
-      expect(utf8_bucket.get_index 'cat_bin', random_utf8_string).
-        to include random_utf8_string.force_encoding('binary')
-
-      # riak gives us binary-encoding back, which is working as intended
-      expect(utf8_bucket.keys).
-        to include random_utf8_string.force_encoding('binary')
-    end
-
-    it 'allows binary strings in bucket and key names and values' do
-      expect(binary_bucket).to be_a Riak::Bucket
-      expect(robj = binary_bucket.new(random_binary_string)).
-        to be_a Riak::RObject
-      robj.content_type = 'text/plain'
-      robj.data = random_binary_string
-      robj.indexes['cat_bin'] = [random_binary_string, 'asdf']
-      expect{ robj.store }.to_not raise_error
-
-      expect(robj2 = binary_bucket.get(random_binary_string)).
-        to be_a Riak::RObject
-      expect(robj2.data).to eq random_binary_string
-
-      robj.raw_data = random_binary_string
-      robj.store
-      robj2.reload
-      expect(robj2.raw_data).to eq random_binary_string
-
-      expect(binary_bucket.get_index 'cat_bin', 'asdf').
-        to include random_binary_string
-      expect(binary_bucket.get_index 'cat_bin', random_binary_string).
-        to include random_binary_string
-
-      expect(binary_bucket.keys).to include random_binary_string
-    end
-
-    it 'throws an exception when non-string used as key' do
-      expect do
-        binary_bucket.get(1234)
-      end.to raise_error ArgumentError, /is not a String/
-    end
-  end
-end

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

@@ -1,142 +0,0 @@
-# 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' }
-
-  let(:utf8_encoding){ Encoding.find 'utf-8' }
-  let(:utf8_string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
-  let(:random_utf8_string){ utf8_string + random_key }
-  let(:utf8_bucket){ bucket_type.bucket random_utf8_string }
-
-  let(:binary_encoding){ Encoding.find 'binary' }
-  let(:binary_string){ "\xff\xff".force_encoding('binary') }
-  let(:random_binary_string){ binary_string + random_key }
-  let(:binary_bucket){ bucket_type.bucket random_binary_string }
-
-  describe 'with utf-8 strings' do
-    it 'creates schemas' do
-      schema = nil
-      expect do
-        schema = Riak::Search::Schema.new test_client, random_utf8_string
-      end.to_not raise_error
-
-      expect(schema).to be_a Riak::Search::Schema
-
-      expect{ schema.create! schema_xml random_utf8_string }.to_not raise_error
-
-      schema2 = Riak::Search::Schema.new test_client, random_utf8_string
-      expect(schema2).to be_exists
-    end
-
-    it 'refuses to create indexes' do
-      index = nil
-      expect do
-        index = Riak::Search::Index.new test_client, random_utf8_string
-      end.to_not raise_error
-
-      expect(index).to be_a Riak::Search::Index
-
-      expect{ index.create! }.to raise_error /Invalid character/
-    end
-
-    it 'queries non-weird indexes' do
-      create_index
-
-      props = Riak::BucketProperties.new utf8_bucket
-      props['search_index'] = index_name
-      props.store
-
-      wait_until do
-        props.reload
-        props['search_index'] == index_name
-      end
-
-      robj = utf8_bucket.new random_utf8_string
-      robj.content_type = 'text/plain'
-      robj.raw_data = <<EOD
-This is due to the write-once, append-only nature of the Bitcask database files.
-High throughput, especially when writing an incoming stream of random items
-Because the data being written doesn't need to be ordered on disk and because
-the log structured design allows for minimal disk head movement during writes
-these operations generally saturate the I/O and disk bandwidth.
-EOD
-      robj.store
-
-      results = nil
-      wait_until do
-        results = index.query('bitcask').results
-        !results.empty?
-      end
-      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(Riak::Util::String.equal_bytes?(results.docs.first.key, robj.key)).to be
-    end
-  end
-
-  describe 'with binary strings' do
-    it 'refuses to create schemas' do
-      schema = nil
-      expect do
-        schema = Riak::Search::Schema.new test_client, random_binary_string
-      end.to_not raise_error
-
-      expect(schema).to be_a Riak::Search::Schema
-
-      # yz will refuse to create files with names that aren't valid utf-8
-      expect{ schema.create! schema_xml random_binary_string }.
-        to raise_error /bad_character/
-    end
-
-
-    it 'refuses to create indexes' do
-      index = nil
-      expect do
-        index = Riak::Search::Index.new test_client, random_binary_string
-      end.to_not raise_error
-
-      expect(index).to be_a Riak::Search::Index
-
-      expect{ index.create! }.to raise_error /Invalid character/
-    end
-
-    # left here for reference: yz can't index documents with \xff\xff in the
-    # key, or presumably bucket name either
-    #     it 'queries non-weird indexes' do
-    #       create_index
-
-    #       props = Riak::BucketProperties.new binary_bucket
-    #       props['search_index'] = index_name
-    #       props.store
-
-    #       wait_until do
-    #         props.reload
-    #         props['search_index'] == index_name
-    #       end
-
-    #       robj = binary_bucket.new random_binary_string
-    #       robj.content_type = 'text/plain'
-    #       robj.raw_data = <<EOD
-    # This is due to the write-once, append-only nature of the Bitcask database files.
-    # High throughput, especially when writing an incoming stream of random items
-    # Because the data being written doesn't need to be ordered on disk and because
-    # the log structured design allows for minimal disk head movement during writes
-    # these operations generally saturate the I/O and disk bandwidth.
-    # EOD
-    #       robj.store
-
-    #       results = nil
-    #       wait_until do
-    #         results = index.query('bitcask').results
-    #         !results.empty?
-    #       end
-    #       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
-    #     end
-  end
-end