riak-client 2.5.0 → 2.6.0

data/spec/riak/secondary_index_spec.rb

@@ -1,225 +0,0 @@
-require 'spec_helper'
-
-describe Riak::SecondaryIndex do
-  before(:each) do
-    @client = Riak::Client.new
-    @bucket = Riak::Bucket.new @client, 'foo'
-  end
-
-  describe "initialization" do
-    it "accepts a bucket, index name, and scalar" do
-      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa' }.not_to raise_error
-      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 12345 }.not_to raise_error
-    end
-
-    it "accepts a bucket, index name, and a range" do
-      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 'aaaa'..'zzzz' }.not_to raise_error
-      expect { Riak::SecondaryIndex.new @bucket, 'asdf', 1..5 }.not_to raise_error
-    end
-  end
-
-  describe "operation" do
-    before(:each) do
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      @args = [@bucket, 'asdf', 'aaaa'..'zzzz', {}]
-      @index = Riak::SecondaryIndex.new *@args
-
-      expect(@backend).to receive(:get_index).with(*@args).and_return(%w{abcd efgh})
-    end
-
-    it "returns an array of keys" do
-      @results = @index.keys
-      expect(@results).to be_a Array
-      expect(@results.first).to be_a String
-    end
-    it "returns an array of values" do
-      expect(@backend).to receive(:fetch_object).with(@bucket, 'abcd', {}).and_return('abcd')
-      expect(@backend).to receive(:fetch_object).with(@bucket, 'efgh', {}).and_return('efgh')
-
-      @results = @index.values
-      expect(@results).to be_a Array
-      expect(@results.length).to eq(2)
-    end
-  end
-
-  describe "streaming" do
-    it "streams keys into a block" do
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      @args = [@bucket, 'asdf', 'aaaa'..'zzzz', {stream: true}]
-      @index = Riak::SecondaryIndex.new *@args
-
-      expect(@backend).to receive(:get_index).with(*@args).and_yield('abcd').and_yield('efgh')
-
-      @index.keys {|b| :noop }
-    end
-  end
-
-  describe "pagination" do
-    it "supports max_results" do
-      @max_results = 5
-
-      @expected_collection = Riak::IndexCollection.new_from_json({
-        'keys' => %w{aaaa bbbb cccc dddd eeee},
-        'continuation' => 'examplecontinuation'
-      }.to_json)
-
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      expect(@backend).
-        to receive(:get_index).
-        with(
-             @bucket,
-             'asdf',
-             ('aaaa'..'zzzz'),
-             :max_results => @max_results
-             ).
-        and_return(@expected_collection)
-      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
-
-
-      @index = Riak::SecondaryIndex.new(
-                                        @bucket,
-                                        'asdf',
-                                        'aaaa'..'zzzz',
-                                        :max_results => @max_results
-                                        )
-
-      @results = @index.keys
-      expect(@results).to be_an Array
-      expect(@results).to eq(@expected_collection)
-      expect(@results.length).to eq(@max_results)
-    end
-
-    it "supports continuations" do
-      @max_results = 5
-
-      @expected_collection = Riak::IndexCollection.new_from_json({
-        'keys' => %w{ffff gggg hhhh}
-      }.to_json)
-
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      expect(@backend).
-        to receive(:get_index).
-        with(
-             @bucket,
-             'asdf',
-             ('aaaa'..'zzzz'),
-             max_results: @max_results,
-             continuation: 'examplecontinuation'
-             ).
-        and_return(@expected_collection)
-      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
-
-
-      @index = Riak::SecondaryIndex.new(
-                                        @bucket,
-                                        'asdf',
-                                        'aaaa'..'zzzz',
-                                        max_results: @max_results,
-                                        continuation: 'examplecontinuation'
-                                        )
-
-      @results = @index.keys
-      expect(@results).to be_an Array
-      expect(@results).to eq(@expected_collection)
-    end
-
-    it "supports a next_page method" do
-      @max_results = 5
-
-      @expected_collection = Riak::IndexCollection.new_from_json({
-        'keys' => %w{aaaa bbbb cccc dddd eeee},
-        'continuation' => 'examplecontinuation'
-      }.to_json)
-
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      expect(@backend).
-        to receive(:get_index).
-        once.
-        with(
-             @bucket,
-             'asdf',
-             ('aaaa'..'zzzz'),
-             :max_results => @max_results
-             ).
-        and_return(@expected_collection)
-      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
-
-
-      @index = Riak::SecondaryIndex.new(
-                                        @bucket,
-                                        'asdf',
-                                        'aaaa'..'zzzz',
-                                        :max_results => @max_results
-                                        )
-
-      @results = @index.keys
-      expect(@results).to eq(@expected_collection)
-
-      @second_collection = Riak::IndexCollection.new_from_json({
-        'keys' => %w{ffff gggg hhhh}
-      }.to_json)
-      expect(@backend).
-        to receive(:get_index).
-        once.
-        with(
-             @bucket,
-             'asdf',
-             ('aaaa'..'zzzz'),
-             max_results: @max_results,
-             continuation: 'examplecontinuation'
-             ).
-        and_return(@second_collection)
-
-      @second_page = @index.next_page
-      @second_results = @second_page.keys
-      expect(@second_results).to eq(@second_collection)
-    end
-  end
-
-  describe "return_terms" do
-    it "optionally gives the index value" do
-      @expected_collection = Riak::IndexCollection.new_from_json({
-        'results' => [
-          {'aaaa' => 'aaaa'},
-          {'bbbb' => 'bbbb'},
-          {'bbbb' => 'bbbb2'}
-        ]
-        }.to_json)
-
-
-      @backend = double 'Backend'
-      allow(@client).to receive(:backend).and_yield(@backend)
-      expect(@backend).
-        to receive(:get_index).
-        with(
-             @bucket,
-             'asdf',
-             ('aaaa'..'zzzz'),
-             :return_terms => true
-             ).
-        and_return(@expected_collection)
-      allow(@backend).to receive(:get_server_version).and_return('1.4.0')
-
-
-      @index = Riak::SecondaryIndex.new(
-                                        @bucket,
-                                        'asdf',
-                                        'aaaa'..'zzzz',
-                                        :return_terms => true
-                                        )
-
-      @results = @index.keys
-      expect(@results).to be_an Array
-      expect(@results).to eq(@expected_collection)
-      expect(@results.with_terms).to eq({
-        'aaaa' => %w{aaaa},
-        'bbbb' => %w{bbbb bbbb2}
-      })
-    end
-  end
-end

data/spec/riak/serializers_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Serializers do
-  shared_examples_for "a serializer" do |type, deserialized, serialized|
-    context "for #{type}" do
-      it "serializes #{deserialized} to #{serialized}" do
-        expect(described_class.serialize(type, deserialized)).to eq(serialized)
-      end
-
-      it "deserializes #{serialized} to #{deserialized}" do
-        expect(described_class.deserialize(type, serialized)).
-          to eq(deserialized)
-      end
-
-      it "round trips properly" do
-        str = described_class.serialize(type, deserialized)
-        expect(described_class.deserialize(type, str)).to eq(deserialized)
-      end
-    end
-  end
-
-  it_behaves_like "a serializer", "text/plain", "a string", "a string"
-  it_behaves_like "a serializer", "application/json", { "a" => 7 }, '{"a":7}'
-  it_behaves_like "a serializer",
-                  "application/x-ruby-marshal",
-                  { a: 3 },
-                  Marshal.dump({ a: 3 })
-
-  described_class::YAML_MIME_TYPES.each do |mime_type|
-    it_behaves_like "a serializer",
-                    mime_type,
-                    { "a" => 7 },
-                    YAML.dump({ "a" => 7 })
-  end
-
-  %w[ serialize deserialize ].each do |meth|
-    describe ".#{meth}" do
-      it 'raises an IOError when given an unrecognized content type' do
-        expect {
-          described_class.send(meth, "application/unrecognized", "string")
-        }.to raise_error(IOError)
-      end
-    end
-  end
-
-  describe "plain text serializer" do
-    it 'calls #to_s to convert the object to a string' do
-      expect(described_class.serialize('text/plain', :a_string)).
-        to eq('a_string')
-    end
-  end
-
-  describe "JSON serializer" do
-    it "respects the max nesting option" do
-      # Sadly, this spec will not fail for me when using yajl-ruby
-      # on Ruby 1.9, even when passing the options to #to_json is
-      # not implemented.
-      Riak.json_options = {:max_nesting => 51}
-      h = {}
-      p = h
-      (1..50).each do |i|
-        p['a'] = {}
-        p = p['a']
-      end
-      s = h.to_json(Riak.json_options)
-      expect {
-        described_class.serialize('application/json', h)
-      }.to_not raise_error
-
-      expect {
-        described_class.deserialize('application/json', s)
-      }.to_not raise_error
-    end
-  end
-
-  describe "a custom serializer" do
-    let(:custom_serializer) do
-      Object.new.tap do |o|
-        def o.dump(string)
-          "The string is: #{string}"
-        end
-
-        def o.load(string)
-          string.sub(/^The string is: /, '')
-        end
-      end
-    end
-
-    it 'can be registered' do
-      described_class['application/custom-type-1'] = custom_serializer
-      expect(described_class['application/custom-type-1']).
-        to be(custom_serializer)
-      # fail
-    end
-
-    it_behaves_like "a serializer",
-                    "application/custom-type-a",
-                    "foo",
-                    "The string is: foo" do
-      before(:each) do
-        described_class['application/custom-type-a'] = custom_serializer
-      end
-    end
-
-    after(:each) do
-      # Make sure to clean up the registered serializer
-      %w{application/custom-type-1 application/custom-type-a}.each do |ctype|
-        described_class.send(:serializers).delete(ctype)
-      end
-    end
-  end
-
-  it_behaves_like "a serializer",
-                  "application/json; charset=UTF-8",
-                  { "a" => 7 },
-                  '{"a":7}'
-  it_behaves_like "a serializer",
-                  "application/json ;charset=UTF-8",
-                  { "a" => 7 },
-                  '{"a":7}'
-end

data/spec/riak/stamp_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'riak/stamp'
-
-describe Riak::Stamp, test_client: true, integration: true do
-  subject { described_class.new test_client }
-  it "generates always increasing integer identifiers" do
-    1000.times do
-      one = subject.next
-      two = subject.next
-      expect([one, two]).to be_all {|i| Integer === i }
-      expect(two).to be > one
-    end
-  end
-
-  it "delays until the next millisecond when the sequence overflows" do
-    old = subject.instance_variable_get(:@timestamp) + 0
-    subject.instance_variable_set(:@sequence, described_class::SEQUENCE_MASK)
-    count = 0
-    # Simulate the time_gen method returning the same thing multiple times
-    allow(subject).to receive(:time_gen) do
-      count += 1
-      if count < 10
-        old
-      else
-        old + 1
-      end
-    end
-    expect((subject.next >> described_class::TIMESTAMP_SHIFT) & described_class::TIMESTAMP_MASK).to eq(old + 1)
-  end
-
-  it "raises an exception when the system clock moves backwards" do
-    old = subject.instance_variable_get(:@timestamp)
-    expect(subject).to receive(:time_gen).and_return(old - 10)
-    expect {
-      subject.next
-    }.to raise_error(Riak::BackwardsClockError)
-  end
-
-  # The client/worker ID should be used for disambiguation, not for
-  # primary ordering.  This breaks from the Snowflake model where the
-  # worker ID is in more significant bits.
-  it "uses the client ID as the bottom component of the identifier" do
-    expect(subject.next & described_class::CLIENT_ID_MASK).to eq(subject.client.client_id.hash & described_class::CLIENT_ID_MASK)
-  end
-
-  context "using a non-integer client ID" do
-    subject { described_class.new(Riak::Client.new(:client_id => "ripple")) }
-    let(:hash) { "ripple".hash }
-
-    it "uses the hash of the client ID as the bottom component of the identifier" do
-      expect(subject.next & described_class::CLIENT_ID_MASK).to eq(subject.client.client_id.hash & described_class::CLIENT_ID_MASK)
-    end
-  end
-end

data/spec/riak/time_series/deletion_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Riak::TimeSeries::Deletion do
-  subject{ described_class.new client, table_name }
-  let(:table_name){ 'GeoCheckin' }
-  let(:client){ instance_double('Riak::Client') }
-  let(:key){ double 'key' }
-  let(:backend) do
-    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
-      allow(client).to receive(:backend).and_yield be
-    end
-  end
-  let(:operator) do
-    Riak::Client::BeefcakeProtobuffsBackend.configured?
-    instance_double(
-      'Riak::Client::BeefcakeProtobuffsBackend::TimeSeriesDeleteOperator'
-    ).tap do |op|
-      allow(backend).to receive(:time_series_delete_operator).
-                         and_return(op)
-    end
-  end
-
-  it 'initializes with client and table name' do
-    expect{ described_class.new client, table_name }.to_not raise_error
-    expect{ described_class.new client }.to raise_error ArgumentError
-  end
-
-  it 'passes keys to delete to a delete operator' do
-    expect{ subject.key = key }.to_not raise_error
-    expect(operator).to receive(:delete).with(table_name, key, Hash.new)
-    expect{ subject.delete! }.to_not raise_error
-  end
-end

data/spec/riak/time_series/listing_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Riak::TimeSeries::List do
-  subject { described_class.new client, table_name }
-  let(:table_name){ 'GeoCheckin' }
-  let(:client){ instance_double('Riak::Client') }
-  let(:key){ double 'key' }
-  let(:backend) do
-    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
-      allow(client).to receive(:backend).and_yield be
-      allow(client).to receive(:convert_timestamp).and_return(true)
-    end
-  end
-  let(:operator) do
-    Riak::Client::BeefcakeProtobuffsBackend.configured?
-    instance_double(
-      'Riak::Client::BeefcakeProtobuffsBackend::TimeSeriesListOperator'
-    ).tap do |op|
-      allow(backend).to receive(:time_series_list_operator).
-                         and_return(op)
-    end
-  end
-
-  let(:list_results) do
-    Riak::TimeSeries::Collection.new.tap do |buf|
-      %w{family series timestamp}
-    end
-  end
-
-  it 'initializes with client and table name' do
-    expect{ described_class.new client, table_name }.to_not raise_error
-    expect{ described_class.new client }.to raise_error ArgumentError
-  end
-
-  it 'passes a block to the operator' do
-    streamer = proc { double 'block contents' }
-
-    expect(operator).to receive(:list).with(table_name, streamer, timeout: nil)
-
-    subject.issue! &streamer
-  end
-
-  it 'returns a list of results' do
-    expect(operator).to receive(:list).
-                         with(table_name, nil, timeout: nil).
-                         and_return(list_results)
-
-    expect(subject.issue!).to eq list_results
-    expect(subject.results).to eq list_results
-  end
-end