riak-client-noenc 1.0.0

data/spec/riak/crdt/set_spec.rb

@@ -0,0 +1,61 @@
+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?).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', '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(: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 'Set 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},
+                                         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

data/spec/riak/crdt/shared_examples.rb

@@ -0,0 +1,74 @@
+shared_examples_for "Map CRDT" do
+  let(:typed_collection){ Riak::Crdt::TypedCollection }
+
+  it 'contains counters' do
+    expect(subject).to respond_to(:counters)
+    expect(subject.counters).to be_an_instance_of typed_collection
+  end
+
+  it 'contains flags' do
+    expect(subject).to respond_to(:flags)
+    expect(subject.counters).to be_an_instance_of typed_collection
+  end
+
+  it 'contains maps' do
+    expect(subject).to respond_to(:maps)
+    expect(subject.counters).to be_an_instance_of typed_collection
+  end
+
+  it 'contains registers' do
+    expect(subject).to respond_to(:registers)
+    expect(subject.counters).to be_an_instance_of typed_collection
+  end
+
+  it 'contains sets' do
+    expect(subject).to respond_to(:sets)
+    expect(subject.counters).to be_an_instance_of typed_collection
+  end
+
+  it 'accepts operations' do
+    expect(subject).to respond_to(:operate)
+  end
+end
+
+shared_examples_for "Counter CRDT" do
+  it 'has a value' do
+    expect(subject).to respond_to :value
+  end
+
+  it 'has an increment method' do
+    expect(subject).to respond_to :increment
+  end
+
+  it 'has a decrement method' do
+    expect(subject).to respond_to :decrement
+  end
+
+  it 'has a batch method' do
+    expect(subject).to respond_to :batch
+  end
+end
+
+shared_examples_for 'Set CRDT' do
+  it 'has a value' do
+    expect(subject).to respond_to :value
+    expect(subject).to respond_to :members
+    expect(subject).to respond_to :to_a
+  end
+
+  it 'has an include? method' do
+    expect(subject).to respond_to :include?
+  end
+
+  it 'has an empty? method' do
+    expect(subject).to respond_to :empty?
+  end
+
+  it 'has an add method' do
+    expect(subject).to respond_to :add
+  end
+
+  it 'has a remove method' do
+    expect(subject).to respond_to :remove
+  end
+end

data/spec/riak/crdt/typed_collection_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe Riak::Crdt::TypedCollection do
+  let(:parent){ double 'parent' }
+  let(:operation){ double 'operation' }
+
+  describe 'initialization' do
+    it "accepts a type, parent, and hash of values" do
+      expect{ described_class.new Riak::Crdt::Counter, parent, {} }.to_not raise_error
+    end
+  end
+
+  describe 'containing' do
+    describe 'registers' do
+      let(:register_class){ Riak::Crdt::InnerRegister }
+      subject do
+        described_class.new register_class, parent, existing: 'existing'
+      end
+
+      it 'exposes them as frozen strings that are really Registers' do
+        expect(subject[:existing]).to eq 'existing'
+        expect(subject['existing']).to eq 'existing'
+        expect(subject[:existing]).to be_an_instance_of register_class
+        expect(subject['existing'].frozen?).to be
+        expect{subject['existing'].gsub!('e', 'a')}.to raise_error
+      end
+
+      describe 'creating and updating' do
+
+        let(:new_value){ 'the new value' }
+
+        it 'asks the register class for an operation' do
+          expect(register_class).to receive(:update).
+            with(new_value).
+            and_return(operation)
+
+          expect(operation).
+            to receive(:name=).
+            with('existing')
+
+          expect(parent).
+            to receive(:operate).
+            with(operation)
+
+          subject['existing'] = new_value
+        end
+      end
+
+      describe 'removing' do
+
+        it 'asks the register class for a remove operation' do
+          expect(register_class).
+            to receive(:delete).
+            and_return(operation)
+
+          expect(operation).
+            to receive(:name=).
+            with('existing')
+
+          expect(parent).
+            to receive(:operate).
+            with(operation)
+
+          subject.delete 'existing'
+        end
+      end
+    end
+    describe 'flags' do
+      let(:flag_class){ Riak::Crdt::InnerFlag }
+      subject do
+        described_class.new flag_class, parent, truthy: true, falsey: false
+      end
+
+      it 'exposes them as booleans' do
+        expect(subject[:truthy]).to eq true
+        expect(subject['falsey']).to eq false
+      end
+
+      it 'updates them' do
+        expect(flag_class).
+          to receive(:update).
+          with(true).
+          and_return(operation)
+
+        expect(operation).
+          to receive(:name=).
+          with('become_truthy')
+
+        expect(parent).
+          to receive(:operate).
+          with(operation)
+
+        subject['become_truthy'] = true
+      end
+
+      it 'deletes them' do
+        expect(flag_class).
+          to receive(:delete).
+          and_return(operation)
+
+        expect(operation).
+          to receive(:name=).
+          with('become_deleted')
+
+        expect(parent).
+          to receive(:operate).
+          with(operation)
+
+        subject.delete 'become_deleted'
+      end
+    end
+    describe 'counters' do
+      let(:counter_class){ Riak::Crdt::InnerCounter }
+
+      subject{ described_class.new counter_class, parent, zero: 0, one: 1 }
+
+      it 'exposes existing ones as Counter instances' do
+        expect(subject['zero']).to be_an_instance_of counter_class
+        expect(subject['zero'].to_i).to eq 0
+
+        expect(subject['one'].to_i).to eq 1
+      end
+
+      it 'exposes new ones as Counter instances' do
+        expect(subject['new_zero']).to be_an_instance_of counter_class
+        expect(subject['new_zero'].to_i).to eq 0
+      end
+
+      it 'allows incrementing and decrementing' do
+        counter_name = 'counter'
+
+        expect(parent).to receive(:operate) do |op|
+          expect(op.name).to eq counter_name
+          expect(op.type).to eq :counter
+          expect(op.value).to eq 1
+        end
+        subject[counter_name].increment
+
+        expect(parent).to receive(:operate) do |op|
+          expect(op.name).to eq counter_name
+          expect(op.type).to eq :counter
+          expect(op.value).to eq -5
+        end
+
+        subject[counter_name].decrement 5
+      end
+    end
+    describe 'sets' do
+      let(:set_class){ Riak::Crdt::InnerSet }
+
+      subject{ described_class.new set_class, parent, brewers: %w{aeropress clever v60}}
+
+      it 'exposes existing ones as Set instances' do
+        expect(subject['brewers']).to be_an_instance_of set_class
+        expect(subject['brewers']).to include 'aeropress'
+      end
+
+      it 'exposes new ones as empty Set instances' do
+        expect(subject['filters']).to be_an_instance_of set_class
+        expect(subject['filters']).to be_empty
+      end
+
+      it 'allows adding and removing' do
+        set_name = 'brewers'
+
+        expect(parent).to receive(:operate) do |op|
+          expect(op.name).to eq set_name
+          expect(op.type).to eq :set
+          expect(op.value).to eq add: 'frenchpress'
+        end
+        subject[set_name].add 'frenchpress'
+
+        expect(parent).to receive(:operate) do |op|
+          expect(op.name).to eq set_name
+          expect(op.type).to eq :set
+          expect(op.value).to eq remove: 'aeropress'
+        end
+        allow(parent).to receive(:context?).and_return(true)
+
+        subject[set_name].remove 'aeropress'
+      end
+    end
+
+    describe 'maps' do
+      let(:map_class){ Riak::Crdt::InnerMap }
+
+      let(:contents) do {a: {
+            counters: {},
+            flags: {},
+            maps: {},
+            registers: {'hello' => 'world'},
+            sets: {}
+          }}
+        end
+
+      let(:inner_map_name){ 'inner map' }
+
+      subject do
+        described_class.new map_class, parent, contents
+      end
+
+      it 'exposes existing ones as populated Map instances' do
+        expect(subject['a']).to be_an_instance_of map_class
+        expect(subject['a'].registers['hello']).to eq 'world'
+      end
+
+      it 'exposes new ones as empty Map instances' do
+        expect(subject['b']).to be_an_instance_of map_class
+        expect(subject['b'].registers['hello']).to be_nil
+      end
+
+      it 'cascades operations to a parent map' do
+        expect(operation).
+          to receive(:name=).
+          with(inner_map_name)
+
+        expect(parent).
+          to receive(:operate).
+          with(operation)
+
+        subject.operate inner_map_name, operation
+      end
+    end
+  end
+end

data/spec/riak/escape_spec.rb

@@ -0,0 +1,72 @@
+
+require 'spec_helper'
+
+describe Riak::Util::Escape do
+  before :each do
+    @object = Object.new
+    @object.extend(Riak::Util::Escape)
+  end
+
+  it "uses URI by default for escaping" do
+    expect(Riak.escaper).to eq(URI)
+  end
+
+  context "when using CGI for escaping" do
+    before { @oldesc, Riak.escaper = Riak.escaper, CGI }
+    after { Riak.escaper = @oldesc }
+
+    it "escapes standard non-safe characters" do
+      expect(@object.escape("some string")).to eq("some%20string")
+      expect(@object.escape("another^one")).to eq("another%5Eone")
+      expect(@object.escape("bracket[one")).to eq("bracket%5Bone")
+    end
+
+    it "escapes slashes" do
+      expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
+    end
+
+    it "converts the bucket or key to a string before escaping" do
+      expect(@object.escape(125)).to eq('125')
+    end
+
+    it "unescapes escaped strings" do
+      expect(@object.unescape("some%20string")).to eq("some string")
+      expect(@object.unescape("another%5Eone")).to eq("another^one")
+      expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")
+      expect(@object.unescape("some%2Finner%2Fpath")).to eq("some/inner/path")
+    end
+  end
+
+  context "when using URI for escaping" do
+    before { @oldesc, Riak.escaper = Riak.escaper, URI }
+    after { Riak.escaper = @oldesc }
+
+    it "escapes standard non-safe characters" do
+      expect(@object.escape("some string")).to eq("some%20string")
+      expect(@object.escape("another^one")).to eq("another%5Eone")
+      expect(@object.escape("--one+two--")).to eq("--one%2Btwo--")
+    end
+
+    it "allows URI-safe characters" do
+      expect(@object.escape("bracket[one")).to eq("bracket[one")
+      expect(@object.escape("sean@basho")).to eq("sean@basho")
+    end
+
+    it "escapes slashes" do
+      expect(@object.escape("some/inner/path")).to eq("some%2Finner%2Fpath")
+    end
+
+    it "converts the bucket or key to a string before escaping" do
+      expect(@object.escape(125)).to eq('125')
+    end
+
+    it "unescapes escaped strings" do
+      expect(@object.unescape("some%20string")).to eq("some string")
+      expect(@object.unescape("another%5Eone")).to eq("another^one")
+      expect(@object.unescape("bracket%5Bone")).to eq("bracket[one")
+      expect(@object.unescape("some%2Finner%2Fpath")).to eq("some/inner/path")
+      expect(@object.unescape("--one%2Btwo--")).to eq("--one+two--")
+      expect(@object.unescape("me%40basho.co")).to eq("me@basho.co")
+    end
+  end
+end

data/spec/riak/feature_detection_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'riak/client/feature_detection'
+
+describe Riak::Client::FeatureDetection do
+  let(:klass) {
+    Class.new do
+      include Riak::Client::FeatureDetection
+    end
+  }
+  subject { klass.new }
+
+  context "when the get_server_version is unimplemented" do
+    it "raises a NotImplementedError" do
+      expect { subject.server_version }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context "when the Riak version is 0.14.x" do
+    before { allow(subject).to receive(:get_server_version).and_return("0.14.2") }
+    it { is_expected.not_to be_mapred_phaseless }
+    it { is_expected.not_to be_pb_indexes }
+    it { is_expected.not_to be_pb_search }
+    it { is_expected.not_to be_pb_conditionals }
+    it { is_expected.not_to be_quorum_controls }
+    it { is_expected.not_to be_tombstone_vclocks }
+    it { is_expected.not_to be_pb_head }
+    it { is_expected.not_to be_http_props_clearable }
+  end
+
+  context "when the Riak version is 1.0.x" do
+    before { allow(subject).to receive(:get_server_version).and_return("1.0.3") }
+    it { is_expected.not_to be_mapred_phaseless }
+    it { is_expected.not_to be_pb_indexes }
+    it { is_expected.not_to be_pb_search }
+    it { is_expected.to be_pb_conditionals }
+    it { is_expected.to be_quorum_controls }
+    it { is_expected.to be_tombstone_vclocks }
+    it { is_expected.to be_pb_head }
+    it { is_expected.not_to be_http_props_clearable }
+  end
+
+  context "when the Riak version is 1.1.x" do
+    before { allow(subject).to receive(:get_server_version).and_return("1.1.4") }
+    it { is_expected.to be_mapred_phaseless }
+    it { is_expected.not_to be_pb_indexes }
+    it { is_expected.not_to be_pb_search }
+    it { is_expected.to be_pb_conditionals }
+    it { is_expected.to be_quorum_controls }
+    it { is_expected.to be_tombstone_vclocks }
+    it { is_expected.to be_pb_head }
+    it { is_expected.not_to be_http_props_clearable }
+  end
+
+  context "when the Riak version is 1.2.x" do
+    before { allow(subject).to receive(:get_server_version).and_return("1.2.1") }
+    it { is_expected.to be_mapred_phaseless }
+    it { is_expected.to be_pb_indexes }
+    it { is_expected.to be_pb_search }
+    it { is_expected.to be_pb_conditionals }
+    it { is_expected.to be_quorum_controls }
+    it { is_expected.to be_tombstone_vclocks }
+    it { is_expected.to be_pb_head }
+    it { is_expected.not_to be_http_props_clearable }
+  end
+
+  context "when the Riak version is 1.3.x" do
+    before { allow(subject).to receive(:get_server_version).and_return("1.3.0") }
+    it { is_expected.to be_mapred_phaseless }
+    it { is_expected.to be_pb_indexes }
+    it { is_expected.to be_pb_search }
+    it { is_expected.to be_pb_conditionals }
+    it { is_expected.to be_quorum_controls }
+    it { is_expected.to be_tombstone_vclocks }
+    it { is_expected.to be_pb_head }
+    it { is_expected.to be_http_props_clearable }
+  end
+end