seomoz-riak-client 1.0.0.pre

data/spec/riak/search_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe "Search features" do
+  describe Riak::Client do
+    before :each do
+      @client = Riak::Client.new
+      @http = mock(Riak::Client::HTTPBackend)
+      @client.stub!(:http).and_return(@http)
+    end
+
+    describe "searching" do
+      it "should exclude the index from the URL when not specified" do
+        @http.should_receive(:get).with(200, "/solr", "select", hash_including("q" => "foo"), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+        @client.search("foo")
+      end
+
+      it "should include extra options in the query string" do
+        @http.should_receive(:get).with(200, "/solr", "select", hash_including('rows' => 30), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+        @client.search("foo", 'rows' => 30)
+      end
+
+      it "should include the index in the URL when specified" do
+        @http.should_receive(:get).with(200, "/solr", "search", "select", hash_including("q" => "foo"), {}).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => "{}"})
+        @client.search("search", "foo")
+      end
+
+      it "should vivify JSON responses" do
+        @http.should_receive(:get).and_return({:code => 200, :headers => {"content-type"=>["application/json"]}, :body => '{"response":{"docs":["foo"]}}'})
+        @client.search("foo").should == {"response" => {"docs" => ["foo"]}}
+      end
+
+      it "should return non-JSON responses raw" do
+        @http.should_receive(:get).and_return({:code => 200, :headers => {"content-type"=>["text/plain"]}, :body => '{"response":{"docs":["foo"]}}'})
+        @client.search("foo").should == '{"response":{"docs":["foo"]}}'
+      end
+    end
+    describe "indexing documents" do
+      it "should exclude the index from the URL when not specified" do
+        @http.should_receive(:post).with(200, "/solr", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+        @client.index({:id => 1, :field => "value"})
+      end
+
+      it "should include the index in the URL when specified" do
+        @http.should_receive(:post).with(200, "/solr", "foo", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+        @client.index("foo", {:id => 1, :field => "value"})
+      end
+
+      it "should raise an error when documents do not contain an id" do
+        @http.stub!(:post).and_return(true)
+        lambda { @client.index({:field => "value"}) }.should raise_error(ArgumentError)
+        lambda { @client.index({:id => 1, :field => "value"}) }.should_not raise_error(ArgumentError)
+      end
+
+      it "should build a Solr <add> request" do
+        expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc></add>')
+        @client.index({'id' => 1, 'field' => "value"})
+      end
+
+      it "should include multiple documents in the <add> request" do
+        expect_update_body('<add><doc><field name="id">1</field><field name="field">value</field></doc><doc><field name="id">2</field><field name="foo">bar</field></doc></add>')
+        @client.index({'id' => 1, 'field' => "value"}, {'id' => 2, 'foo' => "bar"})
+      end
+    end
+
+    describe "removing documents" do
+      it "should exclude the index from the URL when not specified" do
+        @http.should_receive(:post).with(200, "/solr","update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+        @client.remove({:id => 1})
+      end
+
+      it "should include the index in the URL when specified" do
+        @http.should_receive(:post).with(200, "/solr", "foo", "update", anything, anything).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+        @client.remove("foo", {:id => 1})
+      end
+
+      it "should raise an error when document specifications don't include an id or query" do
+        @http.stub!(:post).and_return({:code => 200})
+        lambda { @client.remove({:foo => "bar"}) }.should raise_error(ArgumentError)
+        lambda { @client.remove({:id => 1}) }.should_not raise_error
+      end
+
+      it "should build a Solr <delete> request" do
+        expect_update_body('<delete><id>1</id></delete>')
+        @client.remove(:id => 1)
+        expect_update_body('<delete><query>title:old</query></delete>')
+        @client.remove(:query => "title:old")
+      end
+
+      it "should include multiple specs in the <delete> request" do
+        expect_update_body('<delete><id>1</id><query>title:old</query></delete>')
+        @client.remove({:id => 1}, {:query => "title:old"})
+      end
+    end
+
+    def expect_update_body(body, index=nil)
+      args = [200, "/solr", index, "update", body, {"Content-Type" => "text/xml"}].compact
+      @http.should_receive(:post).with(*args).and_return({:code => 200, :headers => {'content-type' => ['text/html']}, :body => ""})
+    end
+  end
+
+  describe Riak::Bucket do
+    before :each do
+      @client = Riak::Client.new
+      @bucket = Riak::Bucket.new(@client, "foo")
+    end
+
+    def load_without_index_hook
+      @bucket.instance_variable_set(:@props, {"precommit" => []})
+    end
+
+    def load_with_index_hook
+      @bucket.instance_variable_set(:@props, {"precommit" => [{"mod" => "riak_search_kv_hook", "fun" => "precommit"}]})
+    end
+
+    it "should detect whether the indexing hook is installed" do
+      load_without_index_hook
+      @bucket.is_indexed?.should be_false
+
+      load_with_index_hook
+      @bucket.is_indexed?.should be_true
+    end
+
+    describe "enabling indexing" do
+      it "should add the index hook when not present" do
+        load_without_index_hook
+        @bucket.should_receive(:props=).with({"precommit" => [Riak::Bucket::SEARCH_PRECOMMIT_HOOK]})
+        @bucket.enable_index!
+      end
+
+      it "should not modify the precommit when the hook is present" do
+        load_with_index_hook
+        @bucket.should_not_receive(:props=)
+        @bucket.enable_index!
+      end
+    end
+
+    describe "disabling indexing" do
+      it "should remove the index hook when present" do
+        load_with_index_hook
+        @bucket.should_receive(:props=).with({"precommit" => []})
+        @bucket.disable_index!
+      end
+
+      it "should not modify the precommit when the hook is missing" do
+        load_without_index_hook
+        @bucket.should_not_receive(:props=)
+        @bucket.disable_index!
+      end
+    end
+  end
+
+  describe Riak::MapReduce do
+    before :each do
+      @client = Riak::Client.new
+      @mr = Riak::MapReduce.new(@client)
+    end
+
+    describe "using a search query as inputs" do
+      it "should accept a bucket name and query" do
+        @mr.search("foo", "bar OR baz")
+        @mr.inputs.should == {:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]}
+      end
+
+      it "should accept a Riak::Bucket and query" do
+        @mr.search(Riak::Bucket.new(@client, "foo"), "bar OR baz")
+        @mr.inputs.should == {:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]}
+      end
+
+      it "should emit the Erlang function and arguments" do
+        @mr.search("foo", "bar OR baz")
+        @mr.to_json.should include('"inputs":{')
+        @mr.to_json.should include('"module":"riak_search"')
+        @mr.to_json.should include('"function":"mapred_search"')
+        @mr.to_json.should include('"arg":["foo","bar OR baz"]')
+      end
+    end
+  end
+end

data/spec/riak/serializers_spec.rb

@@ -0,0 +1,93 @@
+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
+        described_class.serialize(type, deserialized).should == serialized
+      end
+
+      it "deserializes #{serialized} to #{deserialized}" do
+        described_class.deserialize(type, serialized).should == deserialized
+      end
+
+      it "round trips properly" do
+        str = described_class.serialize(type, deserialized)
+        described_class.deserialize(type, str).should == deserialized
+      end
+    end
+  end
+
+  it_behaves_like "a serializer", "text/plain", "a string", "a string"
+  it_behaves_like "a serializer", "application/json", { "a" => 7 }, %q|{"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 a NotImplementedError when given an unrecognized content type' do
+        expect {
+          described_class.send(meth, "application/unrecognized", "string")
+        }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+
+  describe "plain text serializer" do
+    it 'calls #to_s to convert the object to a string' do
+      described_class.serialize("text/plain", :a_string).should == "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)
+      }.should_not raise_error
+
+      expect {
+        described_class.deserialize('application/json', s)
+      }.should_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
+      described_class['application/custom-type-1'].should be(custom_serializer)
+    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
+  end
+end
+

data/spec/riak/stamp_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'riak/stamp'
+
+describe Riak::Stamp do
+  subject { described_class.new(Riak::Client.new) }
+  it "should generate always increasing integer identifiers" do
+    1000.times do
+      one = subject.next
+      two = subject.next
+      [one, two].should be_all {|i| Integer === i }
+      two.should > one
+    end
+  end
+
+  it "should delay 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
+    subject.stub(:time_gen) do
+      count += 1
+      if count < 10
+        old
+      else
+        old + 1
+      end
+    end
+    ((subject.next >> described_class::TIMESTAMP_SHIFT) & described_class::TIMESTAMP_MASK).should == old + 1
+  end
+
+  it "should raise an exception when the system clock moves backwards" do
+    old = subject.instance_variable_get(:@timestamp)
+    subject.should_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 "should use the client ID as the bottom component of the identifier" do
+    (subject.next & described_class::CLIENT_ID_MASK).should == subject.client.client_id & 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 "should use the hash of the client ID as the bottom component of the identifier" do
+      (subject.next & described_class::CLIENT_ID_MASK).should == subject.client.client_id.hash & described_class::CLIENT_ID_MASK
+    end
+  end
+end

data/spec/riak/stream_parser_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Riak::Util::Multipart::StreamParser do
+  let(:klass) { Riak::Util::Multipart::StreamParser }
+  let(:block) { mock }
+  it "should detect the initial boundary" do
+    text = "--boundary1\r\nContent-Type: text/plain\r\n\r\nfoo\r\n--boundary1--\r\n"
+    parser = klass.new do |result|
+      result[:headers]['content-type'].should include("text/plain")
+      result[:body].should == "foo"
+    end
+    parser.accept text
+  end
+
+  it "should detect inner multipart bodies" do
+    block.should_receive(:ping).once.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result.should have(1).item
+      result.first[:headers]['content-type'].should include("text/plain")
+      result.first[:body].should == "SCP sloooow...."
+    end
+    File.open("spec/fixtures/multipart-with-body.txt", "r") do |f|
+      while chunk = f.read(16)
+        parser.accept chunk
+      end
+    end
+  end
+
+  it "should yield successive complete chunks to the block" do
+    block.should_receive(:ping).twice.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result[:headers]['content-type'].should include("application/json")
+      lambda { Riak::JSON.parse(result[:body]) }.should_not raise_error
+    end
+    File.open("spec/fixtures/multipart-mapreduce.txt", "r") do |f|
+      while chunk = f.read(16)
+        parser.accept chunk
+      end
+    end
+  end
+
+  it "should yield successive complete bodies to the block, even when multiple bodies are accepted in a single chunk" do
+    block.should_receive(:ping).twice.and_return(true)
+    parser = klass.new do |result|
+      block.ping
+      result[:headers]['content-type'].should include("application/json")
+      lambda { Riak::JSON.parse(result[:body]) }.should_not raise_error
+    end
+    parser.accept File.read("spec/fixtures/multipart-mapreduce.txt")
+  end
+end

data/spec/riak/walk_spec_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Riak::WalkSpec do
+  describe "initializing" do
+    describe "with a hash" do
+      it "should be empty by default" do
+        spec = Riak::WalkSpec.new({})
+        spec.bucket.should == "_"
+        spec.tag.should == "_"
+        spec.keep.should be_false
+      end
+
+      it "should extract the bucket" do
+        spec = Riak::WalkSpec.new({:bucket => "foo"})
+        spec.bucket.should == "foo"
+        spec.tag.should == "_"
+        spec.keep.should be_false
+      end
+
+      it "should extract the tag" do
+        spec = Riak::WalkSpec.new({:tag => "foo"})
+        spec.bucket.should == "_"
+        spec.tag.should == "foo"
+        spec.keep.should be_false
+      end
+
+      it "should extract the keep" do
+        spec = Riak::WalkSpec.new({:keep => true})
+        spec.bucket.should == "_"
+        spec.tag.should == "_"
+        spec.keep.should be_true
+      end
+    end
+
+    describe "with three arguments for bucket, tag, and keep" do
+      it "should assign the bucket, tag, and keep" do
+        spec = Riak::WalkSpec.new("foo", "next", false)
+        spec.bucket.should == "foo"
+        spec.tag.should == "next"
+        spec.keep.should be_false
+      end
+
+      it "should make the bucket '_' when false or nil" do
+        spec = Riak::WalkSpec.new(nil, "next", false)
+        spec.bucket.should == "_"
+        spec = Riak::WalkSpec.new(false, "next", false)
+        spec.bucket.should == "_"
+      end
+
+      it "should make the tag '_' when false or nil" do
+        spec = Riak::WalkSpec.new("foo", nil, false)
+        spec.tag.should == "_"
+        spec = Riak::WalkSpec.new("foo", false, false)
+        spec.tag.should == "_"
+      end
+
+      it "should make the keep false when false or nil" do
+        spec = Riak::WalkSpec.new(nil, nil, nil)
+        spec.keep.should be_false
+        spec = Riak::WalkSpec.new(nil, nil, false)
+        spec.keep.should be_false
+      end
+    end
+
+    it "should raise an ArgumentError for invalid arguments" do
+      lambda { Riak::WalkSpec.new }.should raise_error(ArgumentError)
+      lambda { Riak::WalkSpec.new("foo") }.should raise_error(ArgumentError)
+      lambda { Riak::WalkSpec.new("foo","bar") }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "converting to a string" do
+    before :each do
+      @spec = Riak::WalkSpec.new({})
+    end
+
+    it "should be the empty spec by default" do
+      @spec.to_s.should == "_,_,_"
+    end
+
+    it "should include the bucket when set" do
+      @spec.bucket = "foo"
+      @spec.to_s.should == "foo,_,_"
+    end
+
+    it "should include the tag when set" do
+      @spec.tag = "next"
+      @spec.to_s.should == "_,next,_"
+    end
+
+    it "should include the keep when true" do
+      @spec.keep = true
+      @spec.to_s.should == "_,_,1"
+    end
+  end
+
+  describe "creating from a list of parameters" do
+    it "should detect hashes and WalkSpecs interleaved with other parameters" do
+      specs = Riak::WalkSpec.normalize(nil,"next",nil,{:bucket => "foo"},Riak::WalkSpec.new({:tag => "child", :keep => true}))
+      specs.should have(3).items
+      specs.should be_all {|s| s.kind_of?(Riak::WalkSpec) }
+      specs.join("/").should == "_,next,_/foo,_,_/_,child,1"
+    end
+  end
+
+  describe "matching other objects with ===" do
+    before :each do
+      @spec = Riak::WalkSpec.new({})
+    end
+
+    it "should not match objects that aren't links or walk specs" do
+      @spec.should_not === "foo"
+    end
+
+    describe "matching links" do
+      before :each do
+        @link = Riak::Link.new("/riak/foo/bar", "next")
+      end
+
+      it "should match a link when the bucket and tag are not specified" do
+        @spec.should === @link
+      end
+
+      it "should match a link when the bucket is the same" do
+        @spec.bucket = "foo"
+        @spec.should === @link
+      end
+
+      it "should not match a link when the bucket is different" do
+        @spec.bucket = "bar"
+        @spec.should_not === @link
+      end
+
+      it "should match a link when the tag is the same" do
+        @spec.tag = "next"
+        @spec.should === @link
+      end
+
+      it "should not match a link when the tag is different" do
+        @spec.tag = "previous"
+        @spec.should_not === @link
+      end
+
+      it "should match a link when the bucket and tag are the same" do
+        @spec.bucket = "foo"
+        @spec.should === @link
+      end
+    end
+
+    describe "matching walk specs" do
+      before :each do
+        @other = Riak::WalkSpec.new({})
+      end
+
+      it "should match a walk spec that is equivalent" do
+        @spec.should === @other
+      end
+
+      it "should not match a walk spec that has a different keep value" do
+        @other.keep = true
+        @spec.should_not === @other
+      end
+
+      it "should match a walk spec with a more specific bucket" do
+        @other.bucket = "foo"
+        @spec.should === @other
+      end
+
+      it "should match a walk spec with the same bucket" do
+        @other.bucket = "foo"; @spec.bucket = "foo"
+        @spec.should === @other
+      end
+
+      it "should not match a walk spec with a different bucket" do
+        @other.bucket = "foo"; @spec.bucket = "bar"
+        @spec.should_not === @other
+      end
+
+      it "should match a walk spec with a more specific tag" do
+        @other.tag = "next"
+        @spec.should === @other
+      end
+
+      it "should match a walk spec with the same tag" do
+        @other.tag = "next"; @spec.tag = "next"
+        @spec.should === @other
+      end
+
+      it "should not match a walk spec with a different tag" do
+        @other.tag = "next"; @spec.tag = "previous"
+        @spec.should_not === @other
+      end
+    end
+  end
+end