riak-client 1.4.5 → 2.0.0.rc1

data/spec/riak/core_ext/to_param_spec.rb

@@ -3,13 +3,13 @@ describe Riak do
   require 'riak/core_ext/to_param'
 
   it "should do param conversion correctly" do
-    { :name => 'David', :nationality => 'Danish' }.to_param.should == "name=David&nationality=Danish"
+    expect({ :name => 'David', :nationality => 'Danish' }.to_param).to eq("name=David&nationality=Danish")
   end
 
   # Based on the activesupport implementation.
   # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/to_param.rb
   it "should do param conversion correctly with a namespace" do
-    { :name => 'David', :nationality => 'Danish' }.to_param('user').should == "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+    expect({ :name => 'David', :nationality => 'Danish' }.to_param('user')).to eq("user%5Bname%5D=David&user%5Bnationality%5D=Danish")
   end
 
 end

data/spec/riak/counter_spec.rb

@@ -5,21 +5,21 @@ describe Riak::Counter do
     before :each do
       @bucket = Riak::Bucket.allocate
       @key = 'key'
-      @bucket.stub allow_mult: true
-      @bucket.stub(client: mock('client'))
-      @bucket.stub('is_a?' => true)
+      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 "should set the bucket and key" do
       ctr = Riak::Counter.new @bucket, @key
-      ctr.bucket.should == @bucket
-      ctr.key.should == @key
+      expect(ctr.bucket).to eq(@bucket)
+      expect(ctr.key).to eq(@key)
     end
 
     it "should require allow_mult" do
       @bad_bucket = Riak::Bucket.allocate
-      @bad_bucket.stub allow_mult: false
-      @bad_bucket.stub(client: mock('client'))
+      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)
       
@@ -28,20 +28,20 @@ describe Riak::Counter do
   
   describe "incrementing and decrementing" do
     before :each do
-      @backend = mock 'backend'
+      @backend = double 'backend'
 
-      @client = mock 'client'
-      @client.stub(:backend).and_yield @backend
+      @client = double 'client'
+      allow(@client).to receive(:backend).and_yield @backend
 
       @bucket = Riak::Bucket.allocate
-      @bucket.stub allow_mult: true
-      @bucket.stub client: @client
+      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| @backend.should_receive(:post_counter).with(@bucket, @key, n, {})}
+      @increment_expectation = proc{|n| expect(@backend).to receive(:post_counter).with(@bucket, @key, n, {})}
     end
 
     it "should increment by 1 by default" do
@@ -90,21 +90,21 @@ describe Riak::Counter do
         {pb_port: "100#{n}7"}
       end
 
-      @fake_pool = mock 'pool'
-      @backend = mock 'backend'
+      @fake_pool = double 'pool'
+      @backend = double 'backend'
         
-      @client = Riak::Client.new nodes: @nodes, protocol: 'pbc'
+      @client = Riak::Client.new nodes: @nodes
       @client.instance_variable_set :@protobuffs_pool, @fake_pool
 
-      @fake_pool.stub(:take).and_yield(@backend)
+      allow(@fake_pool).to receive(:take).and_yield(@backend)
 
       @bucket = Riak::Bucket.allocate
-      @bucket.stub allow_mult: true
-      @bucket.stub client: @client
+      allow(@bucket).to receive(:allow_mult).and_return(true)
+      allow(@bucket).to receive(:client).and_return(@client)
 
       @key = 'key'
 
-      @expect_post = @backend.should_receive(:post_counter).with(@bucket, @key, 1, {})
+      @expect_post = expect(@backend).to receive(:post_counter).with(@bucket, @key, 1, {})
 
       @ctr = Riak::Counter.new @bucket, @key
     end

data/spec/riak/crdt/counter_spec.rb

@@ -0,0 +1,52 @@
+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?).and_return(true)
+    end
+  end
+  it 'should be initialized 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(: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)
+    end
+    
+    include_examples 'Counter CRDT'
+
+    it 'should batch 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/inner_counter_spec.rb

@@ -0,0 +1,21 @@
+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 'should send 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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Riak::Crdt::InnerFlag do
+  let(:parent){ double 'parent' }
+  describe 'a truthy flag' do
+    subject { described_class.new parent, true }
+
+    it 'should feel truthy' do
+      expect(subject).to be
+    end
+  end
+  
+  describe 'a falsey flag' do
+    subject { described_class.new parent, false }
+
+    it 'should feel falsey' do
+      expect(subject).to_not be
+    end
+  end
+
+  describe 'updating' do
+    let(:new_value){ false }
+    
+    it 'should ask 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 'should ask 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

@@ -0,0 +1,47 @@
+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 'should be 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 'should ask 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 'should wrap 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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Riak::Crdt::InnerRegister do
+  let(:parent){ double 'parent' }
+  subject { described_class.new parent, "espressos" }
+
+  it 'should feel 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 'should be frozen' do
+      expect(subject.frozen?).to be
+    end
+    it "shouldn'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 "should ask 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 'should ask 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

@@ -0,0 +1,33 @@
+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 'should send 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

@@ -0,0 +1,77 @@
+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?).and_return(true)
+      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 'should queue 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 'should submit 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

data/spec/riak/crdt/set_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require_relative 'shared_examples'
+
+describe Riak::Crdt::Set do
+  let(:bucket) do
+    double('bucket').tap do |b|
+      allow(b).to receive(:name).and_return('bucket')
+      allow(b).to receive(:is_a?).and_return(true)
+    end
+  end
+
+  it 'should be initialized with bucket, key, and optional bucket-type' do
+    expect{described_class.new bucket, 'key', 'optional 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(: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)
+    end
+
+    include_examples 'Set CRDT'
+
+    it 'should batch 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},
+                                         remove: %w{foxtrot}
+                                       })
+      }.
+        and_return(response)
+
+      subject.instance_variable_set :@context, 'placeholder'
+
+      subject.batch do |s|
+        s.add 'alpha'
+        s.add 'bravo'
+        s.remove 'foxtrot'
+      end
+    end
+  end
+end