riak-client 2.5.0 → 2.6.0

data/spec/riak/counter_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Counter do
-  describe "initialization" do
-    before :each do
-      @bucket = Riak::Bucket.allocate
-      @key = 'key'
-      allow(@bucket).to receive(:allow_mult).and_return(true)
-      allow(@bucket).to receive(:client).and_return(double('client'))
-      allow(@bucket).to receive('is_a?').and_return(true)
-    end
-
-    it "sets the bucket and key" do
-      ctr = Riak::Counter.new @bucket, @key
-      expect(ctr.bucket).to eq(@bucket)
-      expect(ctr.key).to eq(@key)
-    end
-
-    it "requires allow_mult" do
-      @bad_bucket = Riak::Bucket.allocate
-      allow(@bad_bucket).to receive(:allow_mult).and_return(false)
-      allow(@bad_bucket).to receive(:client).and_return(double('client'))
-
-      expect{ctr = Riak::Counter.new @bad_bucket, @key}.to raise_error(ArgumentError)
-
-    end
-  end
-
-  describe "incrementing and decrementing" do
-    before :each do
-      @backend = double 'backend'
-
-      @client = double 'client'
-      allow(@client).to receive(:backend).and_yield @backend
-
-      @bucket = Riak::Bucket.allocate
-      allow(@bucket).to receive(:allow_mult).and_return(true)
-      allow(@bucket).to receive(:client).and_return(@client)
-
-      @key = 'key'
-
-      @ctr = Riak::Counter.new @bucket, @key
-
-      @increment_expectation = proc{|n| expect(@backend).to receive(:post_counter).with(@bucket, @key, n, {})}
-    end
-
-    it "increments by 1 by default" do
-      @increment_expectation[1]
-      @ctr.increment
-    end
-
-    it "increments by positive numbers" do
-      @increment_expectation[15]
-      @ctr.increment 15
-    end
-
-    it "increments by negative numbers" do
-      @increment_expectation[-12]
-      @ctr.increment -12
-    end
-
-    it "decrements by 1 by default" do
-      @increment_expectation[-1]
-      @ctr.decrement
-    end
-
-    it "decrements by positive numbers" do
-      @increment_expectation[-30]
-      @ctr.decrement 30
-    end
-
-    it "decrements by negative numbers" do
-      @increment_expectation[41]
-      @ctr.decrement -41
-    end
-
-    it "forbids incrementing by non-integers" do
-      [1.1, nil, :'1', '1', 2.0/2, [1]].each do |candidate|
-        expect do
-          @ctr.increment candidate
-          raise candidate.to_s
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "failure modes" do
-    before :each do
-      @nodes = 10.times.map do |n|
-        {pb_port: "100#{n}7"}
-      end
-
-      @fake_pool = double 'pool'
-      @backend = double 'backend'
-
-      @client = Riak::Client.new nodes: @nodes
-      @client.instance_variable_set :@protobuffs_pool, @fake_pool
-
-      allow(@fake_pool).to receive(:take).and_yield(@backend)
-
-      @bucket = Riak::Bucket.allocate
-      allow(@bucket).to receive(:allow_mult).and_return(true)
-      allow(@bucket).to receive(:client).and_return(@client)
-
-      @key = 'key'
-
-      @expect_post = expect(@backend).to receive(:post_counter).with(@bucket, @key, 1, {})
-
-      @ctr = Riak::Counter.new @bucket, @key
-    end
-
-    it "doesn't retry on timeout" do
-      @expect_post.once.and_raise('timeout')
-      expect(proc { @ctr.increment }).to raise_error
-    end
-
-    it "doesn't retry on quorum failure" do
-      @expect_post.once.and_raise('quorum not satisfied')
-      expect(proc { @ctr.increment }).to raise_error
-    end
-  end
-end

data/spec/riak/crdt/counter_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::Counter do
-  let(:bucket) do
-    double('bucket').tap do |b|
-      allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).with(Riak::Bucket).and_return(true)
-      allow(b).to receive(:is_a?).with(Riak::BucketTyped::Bucket).and_return(false)
-    end
-  end
-  it 'initializes with bucket, key, and optional bucket-type' do
-    expect{ described_class.new bucket, 'key' }.to_not raise_error
-    expect{ described_class.new bucket, 'key', 'type' }.to_not raise_error
-  end
-
-  subject{ described_class.new bucket, 'key' }
-
-  describe 'with a client' do
-    let(:response){ double 'response', key: nil }
-    let(:operator){ double 'operator' }
-    let(:loader){ double 'loader', get_loader_for_value: nil }
-    let(:backend){ double 'backend' }
-    let(:client){ double 'client' }
-
-    before(:each) do
-      allow(bucket).to receive(:client).and_return(client)
-      allow(client).to receive(:backend).and_yield(backend)
-      allow(backend).to receive(:crdt_operator).and_return(operator)
-      allow(backend).to receive(:crdt_loader).and_return(loader)
-    end
-
-    include_examples 'Counter CRDT'
-
-    it 'batches properly' do
-      expect(operator).
-        to receive(:operate) { |bucket, key, type, operations|
-        expect(bucket).to eq bucket
-        expect(key).to eq 'key'
-        expect(type).to eq subject.bucket_type
-
-        expect(operations).to be_a Riak::Crdt::Operation::Update
-        expect(operations.value).to eq 5
-      }.
-        and_return(response)
-
-      subject.batch do |s|
-        s.increment 4 # 4
-        s.decrement 2 # 2
-        s.increment 4 # 6
-        s.decrement   # 5
-      end
-    end
-  end
-end

data/spec/riak/crdt/hyper_log_log_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::HyperLogLog, hll: true do
-  let(:bucket) do
-    double('bucket').tap do |b|
-      allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).with(Riak::Bucket).and_return(true)
-      allow(b).to receive(:is_a?).with(Riak::BucketTyped::Bucket).and_return(false)
-    end
-  end
-
-  it 'initializes with bucket, key, and bucket-type' do
-    expect{described_class.new bucket, 'key', 'bucket type'}.
-      to_not raise_error
-  end
-
-  subject{ described_class.new bucket, 'key' }
-
-  describe 'with a client' do
-    let(:response){ double 'response', key: nil }
-    let(:operator){ double 'operator' }
-    let(:loader){ double 'loader', get_loader_for_value: nil }
-    let(:backend){ double 'backend' }
-    let(:client){ double 'client' }
-
-    before(:each) do
-      allow(bucket).to receive(:client).and_return(client)
-      allow(client).to receive(:backend).and_yield(backend)
-      allow(backend).to receive(:crdt_operator).and_return(operator)
-      allow(backend).to receive(:crdt_loader).and_return(loader)
-    end
-
-    include_examples 'HyperLogLog CRDT'
-
-    it 'batches properly' do
-      expect(operator).
-        to receive(:operate) { |bucket, key, type, operations|
-          expect(bucket).to eq bucket
-          expect(key).to eq 'key'
-          expect(type).to eq subject.bucket_type
-
-          expect(operations).to be_a Riak::Crdt::Operation::Update
-          expect(operations.value).to eq({add: %w{alpha bravo}})
-        }.
-        and_return(response)
-
-      subject.instance_variable_set :@context, 'placeholder'
-
-      subject.batch do |s|
-        s.add 'alpha'
-        s.add 'bravo'
-      end
-    end
-  end
-end

data/spec/riak/crdt/inner_counter_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::InnerCounter do
-  let(:parent){ double 'parent' }
-  let(:counter_name){ 'counter name' }
-  subject do
-    described_class.new(parent, 0).tap do |c|
-      c.name = counter_name
-    end
-  end
-
-  include_examples 'Counter CRDT'
-
-  it 'sends increments to the parent' do
-    expect(parent).to receive(:increment).
-      with(counter_name, 1)
-
-    subject.increment
-  end
-end

data/spec/riak/crdt/inner_flag_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Crdt::InnerFlag do
-  let(:parent){ double 'parent' }
-  describe 'a truthy flag' do
-    subject { described_class.new parent, true }
-
-    it 'feels truthy' do
-      expect(subject).to be
-    end
-  end
-
-  describe 'a falsey flag' do
-    subject { described_class.new parent, false }
-
-    it 'feels falsey' do
-      expect(subject).to_not be
-    end
-  end
-
-  describe 'updating' do
-    let(:new_value){ false }
-
-    it 'asks the class for an update operation' do
-      operation = described_class.update(new_value)
-
-      expect(operation.value).to eq new_value
-      expect(operation.type).to eq :flag
-    end
-  end
-
-  describe 'deleting' do
-    it 'asks the class for a delete operation' do
-      operation = described_class.delete
-
-      expect(operation.type).to eq :flag
-    end
-  end
-end

data/spec/riak/crdt/inner_map_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::InnerMap do
-  let(:parent){ double 'parent' }
-  subject{ described_class.new parent, {} }
-
-  include_examples 'Map CRDT'
-
-  let(:populated_contents) do
-    {
-      counters: {alpha: 0},
-      flags: {bravo: true},
-      maps: {},
-      registers: {delta: 'the expendables' },
-      sets: {echo: %w{stallone statham li lundgren}}
-    }
-  end
-
-  it 'is initializable with a nested hash of maps' do
-    expect{described_class.new parent, populated_contents}.
-      to_not raise_error
-  end
-
-  describe 'deleting the inner map' do
-    it 'asks the class for a delete operation' do
-      operation = described_class.delete
-
-      expect(operation.type).to eq :map
-    end
-  end
-
-  describe 'receiving an operation' do
-    let(:inner_operation){ double 'inner operation' }
-    it 'wraps the operation in an update operation and pass it to the parent' do
-      subject.name = 'name'
-
-      expect(parent).to receive(:operate) do |name, op|
-        expect(name).to eq 'name'
-        expect(op.type).to eq :map
-        expect(op.value).to eq inner_operation
-      end
-
-      subject.operate inner_operation
-    end
-  end
-end

data/spec/riak/crdt/inner_register_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Crdt::InnerRegister do
-  let(:parent){ double 'parent' }
-  subject { described_class.new parent, "espressos" }
-
-  it 'feels like a string' do
-    expect(subject).to match 'espressos'
-    expect{ subject.gsub('s', 'x') }.to_not raise_error
-    expect(subject.gsub('s', 'x')).to eq 'exprexxox'
-  end
-
-  describe 'immutability' do
-    it 'is frozen' do
-      expect(subject.frozen?).to be
-    end
-    it "isn't be gsub!-able" do
-      # "gsub!-able" is awful, open to suggestions
-      expect{ subject.gsub!('s', 'x') }.to raise_error
-    end
-  end
-
-  describe 'updating' do
-    let(:new_value){ 'new value' }
-    it "asks the class for an update operation" do
-      operation = described_class.update(new_value)
-
-      expect(operation.value).to eq new_value
-      expect(operation.type).to eq :register
-    end
-  end
-
-  describe 'deleting' do
-    it 'asks the class for a delete operation' do
-      operation = described_class.delete
-
-      expect(operation.type).to eq :register
-    end
-  end
-end

data/spec/riak/crdt/inner_set_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::InnerSet do
-  let(:parent){ double 'parent' }
-  let(:set_name){ 'set name' }
-  subject do
-    described_class.new(parent, []).tap do |s|
-      s.name = set_name
-    end
-  end
-
-  include_examples 'Set CRDT'
-
-  it 'sends additions to the parent' do
-    expect(parent).to receive(:operate) do |name, op|
-      expect(name).to eq set_name
-      expect(op.type).to eq :set
-      expect(op.value).to eq add: 'el'
-    end
-
-    subject.add 'el'
-
-    expect(parent).to receive(:operate) do |name, op|
-      expect(name).to eq set_name
-      expect(op.type).to eq :set
-      expect(op.value).to eq remove: 'el2'
-    end
-    allow(parent).to receive(:context?).and_return(true)
-
-    subject.remove 'el2'
-  end
-end

data/spec/riak/crdt/map_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-require_relative 'shared_examples'
-
-describe Riak::Crdt::Map do
-  let(:bucket) do
-    double('bucket').tap do |b|
-      allow(b).to receive(:name).and_return('bucket')
-      allow(b).to receive(:is_a?).with(Riak::Bucket).and_return(true)
-      allow(b).to receive(:is_a?).with(Riak::BucketTyped::Bucket).and_return(false)
-      allow(b).to receive(:client).and_return(client)
-    end
-  end
-  let(:operator){ double 'operator' }
-  let(:loader){ double 'loader' }
-  let(:backend){ double 'backend' }
-  let(:client){ double 'client' }
-  let(:key){ 'map' }
-
-  before(:each) do
-    allow(client).to receive(:backend).and_yield(backend)
-    allow(backend).to receive(:crdt_operator).and_return(operator)
-    allow(backend).to receive(:crdt_loader).and_return(loader)
-    allow(loader).to receive(:load).and_return({})
-    allow(loader).to receive(:context).and_return('context')
-  end
-
-  subject{ described_class.new bucket, key }
-
-  include_examples 'Map CRDT'
-
-  describe 'batch mode' do
-    it 'queues up operations' do
-      expect(operator).
-        to receive(:operate) do |bucket, key_arg, type, operations|
-
-        expect(bucket).to eq bucket
-        expect(key_arg).to eq key
-        expect(type).to eq subject.bucket_type
-
-        expect(operations.length).to eq 2
-
-        expect(operations.first).to be_a Riak::Crdt::Operation::Update
-
-        expect(operations.first.value).to be_a Riak::Crdt::Operation::Update
-      end
-
-      subject.batch do |s|
-        s.registers['hello'] = 'hello'
-        s.maps['goodbye'].flags['okay'] = true
-      end
-    end
-  end
-
-  describe 'immediate mode' do
-    it 'submits member operations immediately' do
-      expect(operator).
-        to receive(:operate) do |bucket, key_arg, type, operations|
-
-        expect(bucket).to eq bucket
-        expect(key_arg).to eq key
-        expect(type).to eq subject.bucket_type
-
-        expect(operations.length).to eq 1
-
-        expect(operations.first).to be_a Riak::Crdt::Operation::Update
-
-        inner_op = operations.first.value
-
-        expect(inner_op).to be_a Riak::Crdt::Operation::Update
-        expect(inner_op.name).to eq 'hasta'
-        expect(inner_op.type).to eq :register
-        expect(inner_op.value).to eq 'la vista'
-      end
-
-      subject.registers['hasta'] = 'la vista' # baby
-    end
-  end
-end