riak-client 2.5.0 → 2.6.0

data/spec/riak/index_collection_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Riak::IndexCollection do
-  describe "json initialization" do
-    it "accepts a list of keys" do
-      @input = {
-        'keys' => %w{first second third}
-      }.to_json
-      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
-      expect(%w{first second third}).to eq(@coll)
-    end
-
-    it "accepts a list of keys and a continuation" do
-      @input = {
-        'keys' => %w{first second third},
-        'continuation' => 'examplecontinuation'
-      }.to_json
-      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
-      expect(%w{first second third}).to eq(@coll)
-      expect(@coll.continuation).to eq('examplecontinuation')
-    end
-
-    it "accepts a list of results hashes" do
-      @input = {
-        'results' => [
-          {'first' => 'first'},
-          {'second' => 'second'},
-          {'second' => 'other'}
-        ]
-      }.to_json
-
-      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
-      expect(%w{first second other}).to eq(@coll)
-      expect({'first' => %w{first}, 'second' => %w{second other}}).to eq(@coll.with_terms)
-    end
-
-    it "accepts a list of results hashes and a continuation" do
-      @input = {
-        'results' => [
-          {'first' => 'first'},
-          {'second' => 'second'},
-          {'second' => 'other'}
-        ],
-        'continuation' => 'examplecontinuation'
-      }.to_json
-
-      expect { @coll = Riak::IndexCollection.new_from_json @input }.not_to raise_error
-      expect(%w{first second other}).to eq(@coll)
-      expect(@coll.continuation).to eq('examplecontinuation')
-      expect({'first' => %w{first}, 'second' => %w{second other}}).to eq(@coll.with_terms)
-    end
-  end
-end

data/spec/riak/instrumentation_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client do
-
-  before do
-    @client = Riak::Client.new
-    @backend = double("Backend")
-    allow(@client).to receive(:backend).and_yield(@backend)
-    allow(@client).to receive(:http).and_yield(@backend)
-    @bucket = Riak::Bucket.new(@client, "foo")
-
-    @events = []
-    @notifier = ActiveSupport::Notifications.notifier
-    @notifier.subscribe { |*args| (@events ||= []) << event(*args) }
-  end
-
-  describe "instrumentation", instrumentation: true do
-
-    it "should notify on the 'buckets' operation" do
-      expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_buckets') do
-        @client.buckets
-      end
-    end
-
-    it "should notify on the 'list_buckets' operation" do
-      expect(@backend).to receive(:list_buckets).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_buckets') do
-        @client.list_buckets
-      end
-    end
-
-    it "should notify on the 'list_keys' operation" do
-      expect(@backend).to receive(:list_keys).and_return(%w{test test2})
-      test_client_event(@client, 'riak.list_keys') do
-        @client.list_keys(@bucket)
-      end
-    end
-
-    it "should notify on the 'get_bucket_props' operation" do
-      expect(@backend).to receive(:get_bucket_props).and_return({})
-      test_client_event(@client, 'riak.get_bucket_props') do
-        @client.get_bucket_props(@bucket)
-      end
-    end
-
-    it "should notify on the 'set_bucket_props' operation" do
-      expect(@backend).to receive(:set_bucket_props).and_return({})
-      test_client_event(@client, 'riak.set_bucket_props') do
-        @client.set_bucket_props(@bucket, {})
-      end
-    end
-
-    it "should notify on the 'clear_bucket_props' operation" do
-      expect(@backend).to receive(:reset_bucket_props).and_return({})
-      test_client_event(@client, 'riak.clear_bucket_props') do
-        @client.clear_bucket_props(@bucket)
-      end
-    end
-
-    it "should notify on the 'get_index' operation" do
-      expect(@backend).to receive(:get_index).and_return({})
-      test_client_event(@client, 'riak.get_index') do
-        @client.get_index(@bucket, 'index', 'query', {})
-      end
-    end
-
-    it "should notify on the 'get_object' operation" do
-      expect(@backend).to receive(:fetch_object).and_return(nil)
-      test_client_event(@client, 'riak.get_object') do
-        @client.get_object(@bucket, 'bar')
-      end
-    end
-
-    it "should notify on the 'store_object' operation" do
-      expect(@backend).to receive(:store_object).and_return(nil)
-      test_client_event(@client, 'riak.store_object') do
-        @client.store_object(Object.new)
-      end
-    end
-
-    it "should notify on the 'reload_object' operation" do
-      expect(@backend).to receive(:reload_object).and_return(nil)
-      test_client_event(@client, 'riak.reload_object') do
-        @client.reload_object(Object.new)
-      end
-    end
-
-    it "should notify on the 'delete_object' operation" do
-      expect(@backend).to receive(:delete_object).and_return(nil)
-      test_client_event(@client, 'riak.delete_object') do
-        @client.delete_object(@bucket, 'bar')
-      end
-    end
-
-    it "should notify on the 'mapred' operation" do
-      @mapred = Riak::MapReduce.new(@client).add('test').map("function(){}").map("function(){}")
-      expect(@backend).to receive(:mapred).and_return(nil)
-      test_client_event(@client, 'riak.map_reduce') do
-        @client.mapred(@mapred)
-      end
-    end
-
-    it "should notify on the 'ping' operation" do
-      expect(@backend).to receive(:ping).and_return(nil)
-      test_client_event(@client, 'riak.ping') do
-        @client.ping
-      end
-    end
-  end
-end
-
-def test_client_event(client, event_name, &block)
-  block.call
-  expect(@events.size).to eql(1)
-  event = @events.first
-  expect(event.name).to eql(event_name)
-  expect(event.payload[:client_id]).to eql(client.client_id)
-end
-
-# name, start, finish, id, payload
-def event(*args)
-  ActiveSupport::Notifications::Event.new(*args)
-end

data/spec/riak/link_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Link do
-  describe "parsing a link header" do
-    it "creates Link objects from the data" do
-      result = Riak::Link.parse('</riak/foo/bar>; rel="tag", </riak/foo>; rel="up"')
-      expect(result).to be_kind_of(Array)
-      expect(result).to be_all {|i| Riak::Link === i }
-    end
-
-    it "sets the bucket, key, url and rel parameters properly" do
-      result = Riak::Link.parse('</riak/foo/bar>; riaktag="tag", </riak/foo>; rel="up"')
-      expect(result[0].url).to eq("/riak/foo/bar")
-      expect(result[0].bucket).to eq("foo")
-      expect(result[0].key).to eq("bar")
-      expect(result[0].rel).to eq("tag")
-      expect(result[1].url).to eq("/riak/foo")
-      expect(result[1].bucket).to eq("foo")
-      expect(result[1].key).to eq(nil)
-      expect(result[1].rel).to eq("up")
-    end
-
-    it "keeps the url intact if it does not point to a bucket or bucket/key" do
-      result = Riak::Link.parse('</mapred>; rel="riak_kv_wm_mapred"')
-      expect(result[0].url).to eq("/mapred")
-      expect(result[0].bucket).to be_nil
-      expect(result[0].key).to be_nil
-    end
-
-    it "parses the Riak 1.0 URL scheme" do
-      result = Riak::Link.parse('</buckets/b/keys/k>; riaktag="tag"').first
-      expect(result.bucket).to eq('b')
-      expect(result.key).to eq('k')
-      expect(result.tag).to eq('tag')
-    end
-  end
-
-  context "converting to a string" do
-    it "to a string appropriate for use in the Link header" do
-      expect(Riak::Link.new("/riak/foo", "up").to_s).to eq('</riak/foo>; riaktag="up"')
-      expect(Riak::Link.new("/riak/foo/bar", "next").to_s).to eq('</riak/foo/bar>; riaktag="next"')
-      expect(Riak::Link.new("/riak", "riak_kv_wm_raw").to_s).to eq('</riak>; riaktag="riak_kv_wm_raw"')
-    end
-
-    it "converts to a string using the new URL scheme" do
-      expect(Riak::Link.new("bucket", "key", "tag").to_s(true)).to eq('</buckets/bucket/keys/key>; riaktag="tag"')
-      expect(Riak::Link.parse('</riak/bucket/key>; riaktag="tag"').first.to_s(true)).to eq('</buckets/bucket/keys/key>; riaktag="tag"')
-    end
-  end
-
-  it "converts to a walk spec when pointing to an object" do
-    expect(Riak::Link.new("/riak/foo/bar", "next").to_walk_spec.to_s).to eq("foo,next,_")
-    expect { Riak::Link.new("/riak/foo", "up").to_walk_spec }.to raise_error
-  end
-
-  it "is equivalent to a link with the same url and rel" do
-    one = Riak::Link.new("/riak/foo/bar", "next")
-    two = Riak::Link.new("/riak/foo/bar", "next")
-    expect(one).to eq(two)
-    expect([one]).to include(two)
-    expect([two]).to include(one)
-  end
-
-  it "unescapes the bucket name" do
-    expect(Riak::Link.new("/riak/bucket%20spaces/key", "foo").bucket).to eq("bucket spaces")
-  end
-
-  it "unescapes the key name" do
-    expect(Riak::Link.new("/riak/bucket/key%2Fname", "foo").key).to eq("key/name")
-  end
-
-  it "doesn't rely on the prefix to equal /riak/ when extracting the bucket and key" do
-    link = Riak::Link.new("/raw/bucket/key", "foo")
-    expect(link.bucket).to eq("bucket")
-    expect(link.key).to eq("key")
-  end
-
-  it "constructs from bucket, key and tag" do
-    link = Riak::Link.new("bucket", "key", "tag")
-    expect(link.bucket).to eq("bucket")
-    expect(link.key).to eq("key")
-    expect(link.tag).to eq("tag")
-    expect(link.url).to eq("/riak/bucket/key")
-  end
-end

data/spec/riak/list_buckets_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Riak::ListBuckets do
-  before :each do
-    @client = Riak::Client.new
-    @backend = double 'backend'
-    @fake_pool = double 'connection pool'
-    allow(@fake_pool).to receive(:take).and_yield(@backend)
-
-    @expect_list = expect(@backend).to receive(:list_buckets)
-
-    @client.instance_variable_set :@protobuffs_pool, @fake_pool
-  end
-
-  describe "non-streaming" do
-    it 'calls the backend without a block' do
-      @expect_list.with({}).and_return(%w{a b c d})
-
-      @client.list_buckets
-    end
-  end
-
-  describe "streaming" do
-    it 'calls the backend with a block' do
-      @expect_list.
-        and_yield(%w{abc abd abe}).
-        and_yield(%w{bbb ccc ddd})
-
-      @yielded = []
-
-      @client.list_buckets do |bucket|
-        @yielded << bucket
-      end
-
-      @yielded.each do |b|
-        expect(b).to be_a Riak::Bucket
-      end
-      expect(@yielded.map(&:name)).to eq(%w{abc abd abe bbb ccc ddd})
-    end
-  end
-end

data/spec/riak/map_reduce/filter_builder_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Riak::MapReduce::FilterBuilder do
-  subject { Riak::MapReduce::FilterBuilder.new }
-  it "evaluates the passed block on initialization" do
-    expect(subject.class.new do
-      matches "foo"
-    end.to_a).to eq([[:matches, "foo"]])
-  end
-
-  it "adds filters to the list" do
-    subject.to_lower
-    subject.similar_to("ripple", 3)
-    expect(subject.to_a).to eq([[:to_lower], [:similar_to, "ripple", 3]])
-  end
-
-  it "adds a logical operation with a block" do
-    subject.OR do
-      starts_with "foo"
-      ends_with "bar"
-    end
-    expect(subject.to_a).to eq([[:or, [[:starts_with, "foo"], [:ends_with, "bar"]]]])
-  end
-
-  it "raises an error on a filter arity mismatch" do
-    expect { subject.less_than }.to raise_error(ArgumentError)
-  end
-
-  it "raises an error when a block is not given to a logical operation" do
-    expect { subject._or }.to raise_error(ArgumentError)
-  end
-end

data/spec/riak/map_reduce/phase_spec.rb

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-describe Riak::MapReduce::Phase do
-  before :each do
-    @js_fun = "function(v,_,_){ return v['values'][0]['data']; }"
-    @erl_fun = "fun(Obj, _KeyData, _Arg) -> [{riak_object:key(Obj), riak_object:get_value(Obj)}] end."
-  end
-
-  it "initializes with a type and a function" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => @js_fun, :language => "javascript")
-    expect(phase.type).to eq(:map)
-    expect(phase.function).to eq(@js_fun)
-    expect(phase.language).to eq("javascript")
-  end
-
-  it "initializes with a type and an MF" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => %w(module function), :language => "erlang")
-    expect(phase.type).to eq(:map)
-    expect(phase.function).to eq(%w(module function))
-    expect(phase.language).to eq("erlang")
-  end
-
-  it "initializes with a type and a bucket/key" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "funs", :key => "awesome_map"}, :language => "javascript")
-    expect(phase.type).to eq(:map)
-    expect(phase.function).to eq({:bucket => "funs", :key => "awesome_map"})
-    expect(phase.language).to eq("javascript")
-  end
-
-  it "assumes the language is erlang when the function is an array" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => %w(module function))
-    expect(phase.language).to eq("erlang")
-  end
-
-  it "assumes the language is javascript when the function is a string and starts with function" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => @js_fun)
-    expect(phase.language).to eq("javascript")
-  end
-
-  it "assumes the language is erlang when the function is a string and starts with anon fun" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => @erl_fun)
-    expect(phase.language).to eq("erlang")
-  end
-
-  it "assumes the language is javascript when the function is a hash" do
-    phase = Riak::MapReduce::Phase.new(:type => :map, :function => {:bucket => "jobs", :key => "awesome_map"})
-    expect(phase.language).to eq("javascript")
-  end
-
-  it "accepts a WalkSpec for the function when a link phase" do
-    phase = Riak::MapReduce::Phase.new(:type => :link, :function => Riak::WalkSpec.new({}))
-    expect(phase.function).to be_kind_of(Riak::WalkSpec)
-  end
-
-  it "raises an error if a WalkSpec is given for a phase type other than :link" do
-    expect { Riak::MapReduce::Phase.new(:type => :map, :function => Riak::WalkSpec.new({})) }.to raise_error(ArgumentError)
-  end
-
-  describe "converting to JSON for the job" do
-    before :each do
-      @phase = Riak::MapReduce::Phase.new(:type => :map, :function => "")
-    end
-
-    [:map, :reduce].each do |type|
-      describe "when a #{type} phase" do
-        before :each do
-          @phase.type = type
-        end
-
-        it "is an object with a single key of '#{type}'" do
-          expect(@phase.to_json).to match(/^\{"#{type}":/)
-        end
-
-        it "includes the language" do
-          expect(@phase.to_json).to match(/"language":/)
-        end
-
-        it "includes the keep value" do
-          expect(@phase.to_json).to match(/"keep":false/)
-          @phase.keep = true
-          expect(@phase.to_json).to match(/"keep":true/)
-        end
-
-        it "includes the function source when the function is a source string" do
-          @phase.function = "function(v,_,_){ return v; }"
-          expect(@phase.to_json).to include(@phase.function)
-          expect(@phase.to_json).to match(/"source":/)
-        end
-
-        it "includes the function name when the function is not a lambda" do
-          @phase.function = "Riak.mapValues"
-          expect(@phase.to_json).to include('"name":"Riak.mapValues"')
-          expect(@phase.to_json).not_to include('"source"')
-        end
-
-        it "includes the bucket and key when referring to a stored function" do
-          @phase.function = {:bucket => "design", :key => "wordcount_map"}
-          expect(@phase.to_json).to include('"bucket":"design"')
-          expect(@phase.to_json).to include('"key":"wordcount_map"')
-        end
-
-        it "includes the module and function when invoking an Erlang function" do
-          @phase.function = %w(riak_mapreduce mapreduce_fun)
-          expect(@phase.to_json).to include('"module":"riak_mapreduce"')
-          expect(@phase.to_json).to include('"function":"mapreduce_fun"')
-        end
-      end
-    end
-
-    describe "when a link phase" do
-      before :each do
-        @phase.type = :link
-        @phase.function = {}
-      end
-
-      it "is an object of a single key 'link'" do
-        expect(@phase.to_json).to match(/^\{"link":/)
-      end
-
-      it "includes the bucket" do
-        expect(@phase.to_json).to match(/"bucket":"_"/)
-        @phase.function[:bucket] = "foo"
-        expect(@phase.to_json).to match(/"bucket":"foo"/)
-      end
-
-      it "includes the tag" do
-        expect(@phase.to_json).to match(/"tag":"_"/)
-        @phase.function[:tag] = "parent"
-        expect(@phase.to_json).to match(/"tag":"parent"/)
-      end
-
-      it "includes the keep value" do
-        expect(@phase.to_json).to match(/"keep":false/)
-        @phase.keep = true
-        expect(@phase.to_json).to match(/"keep":true/)
-        @phase.keep = false
-        @phase.function[:keep] = true
-        expect(@phase.to_json).to match(/"keep":true/)
-      end
-    end
-  end
-end