riak-client-noenc 1.0.0

data/spec/riak/index_collection_spec.rb

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,142 @@
+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