seomoz-riak-client 1.0.0.pre

data/spec/riak/core_ext/to_param_spec.rb

@@ -0,0 +1,15 @@
+
+describe Riak do
+  require 'riak/core_ext/to_param'
+
+  it "should do param conversion correctly" do
+    { :name => 'David', :nationality => 'Danish' }.to_param.should == "name=David&nationality=Danish"
+  end
+
+  # Based on the activesupport implementation.
+  # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/to_param.rb
+  it "should do param conversion correctly with a namespace" do
+    { :name => 'David', :nationality => 'Danish' }.to_param('user').should == "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+  end
+
+end

data/spec/riak/escape_spec.rb

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

data/spec/riak/excon_backend_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+begin
+  require 'excon'
+rescue LoadError
+  warn "Skipping ExconBackend specs, excon library not found."
+else
+  $mock_server = DrbMockServer
+  $mock_server.maybe_start
+
+  describe Riak::Client::ExconBackend do
+    def setup_http_mock(method, uri, options={})
+      method  = method.to_s.upcase
+      uri     = URI.parse(uri)
+      path    = uri.path          || "/"
+      query   = uri.query         || ""
+      body    = options[:body]    || []
+      headers = options[:headers] || {}
+      headers['Content-Type']     ||= "text/plain"
+      status  = options[:status] ? Array(options[:status]).first.to_i : 200
+      @_mock_set = [status, headers, method, path, query, body]
+      $mock_server.expect(*@_mock_set)
+    end
+
+    before :each do
+      @client = Riak::Client.new(:http_port => $mock_server.port, :http_backend => :Excon) # Point to our mock
+      @backend = @client.http
+      @_mock_set = false
+    end
+
+    after :each do
+      if @_mock_set
+        $mock_server.satisfied.should be_true("Expected #{@_mock_set.inspect}, failed")
+      end
+    end
+
+    it_should_behave_like "HTTP backend"
+
+    it "should split long headers into 8KB chunks" do
+      # TODO: This doesn't actually inspect the emitted headers. How
+      # can it?
+      setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "ok")
+      lambda do
+        @backend.put(200, "/riak/", "foo", "body",{"Long-Header" => (["12345678"*10]*100).join(", ") })
+      end.should_not raise_error
+    end
+
+    it "should support IO objects as the request body" do
+      file = File.open(File.expand_path("../../fixtures/cat.jpg", __FILE__), 'rb')
+      lambda do
+        setup_http_mock(:put, @backend.path("/riak/","foo").to_s, :body => "ok")
+        @backend.put(200, "/riak/", "foo", file, {})
+        $mock_server.satisfied.should be_true
+      end.should_not raise_error
+      file.rewind # Have to rewind the file or we hang
+      lambda do
+        setup_http_mock(:post, @backend.path("/riak/","foo").to_s, :body => "ok")
+        @backend.post(200, "/riak/", "foo", file, {})
+        $mock_server.satisfied.should be_true
+      end.should_not raise_error
+    end
+  end
+
+end

data/spec/riak/headers_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Riak::Util::Headers do
+  it "should include the Net::HTTPHeader module" do
+    Riak::Util::Headers.included_modules.should include(Net::HTTPHeader)
+  end
+
+  it "should be initially empty" do
+    Riak::Util::Headers.new.to_hash.should == {}
+  end
+
+  it "should parse a header line into the key and value" do
+    Riak::Util::Headers.parse("Content-Type: text/plain\r\n").should == ["Content-Type", "text/plain"]
+  end
+
+  it "should parse a header line and add it to the collection" do
+    h = Riak::Util::Headers.new
+    h.parse("Content-Type: text/plain\r\n")
+    h.to_hash.should == {"content-type" => ["text/plain"]}
+  end
+
+  it "should split headers larger than 8KB" do
+    # This really tests Net::HTTPHeader#each_capitalized, which is
+    # used by Net::HTTP to write the headers to the socket. It does
+    # not cover the case where a single value is larger than 8KB. If
+    # you're doing that, you have something else wrong.
+    h = Riak::Util::Headers.new
+    10.times do
+      h.add_field "Link", "f" * 820
+    end
+    count = 0
+    h.each_capitalized do |k,v|
+      count += 1
+      "#{k}: #{v}\r\n".length.should < 8192
+    end
+    count.should > 1
+  end
+end

data/spec/riak/http_backend/configuration_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Riak::Client::HTTPBackend::Configuration do
+  before do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+  end
+
+  it "should memoize the server config" do
+    @backend.should_receive(:get).with(200, "/", {}, {}).once.and_return(:headers => {'link' => ['</riak>; rel="riak_kv_wm_link_walker",</mapred>; rel="riak_kv_wm_mapred",</ping>; rel="riak_kv_wm_ping",</riak>; rel="riak_kv_wm_raw",</stats>; rel="riak_kv_wm_stats"']})
+    @backend.send(:riak_kv_wm_link_walker).should == "/riak"
+    @backend.send(:riak_kv_wm_raw).should == "/riak"
+  end
+
+  {
+    :riak_kv_wm_raw => :prefix,
+    :riak_kv_wm_link_walker => :prefix,
+    :riak_kv_wm_mapred => :mapred
+  }.each do |resource, alternate|
+    it "should detect the #{resource} resource from the configuration URL" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
+      @backend.send(resource).should == "/path"
+    end
+    it "should fallback to client.#{alternate} if the #{resource} resource is not found" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => ['</>; rel="top"']})
+      @backend.send(resource).should == @client.send(alternate)
+    end
+    it "should fallback to client.#{alternate} if request fails" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
+      @backend.send(resource).should == @client.send(alternate)
+    end
+  end
+
+  {
+    :riak_kv_wm_ping => "/ping",
+    :riak_kv_wm_stats => "/stats"
+  }.each do |resource, default|
+    it "should detect the #{resource} resource from the configuration URL" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => [%Q{</path>; rel="#{resource}"}]})
+      @backend.send(resource).should == "/path"
+    end
+    it "should fallback to #{default.inspect} if the #{resource} resource is not found" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_return(:headers => {'link' => ['</>; rel="top"']})
+      @backend.send(resource).should == default
+    end
+    it "should fallback to #{default.inspect} if request fails" do
+      @backend.should_receive(:get).with(200, "/", {}, {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, ""))
+      @backend.send(resource).should == default
+    end
+  end
+end

data/spec/riak/http_backend/object_methods_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Riak::Client::HTTPBackend::ObjectMethods do
+  before :each do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+    @bucket = Riak::Bucket.new(@client, "bucket")
+    @object = Riak::RObject.new(@bucket, "bar")
+  end
+
+  describe "loading object data from the response" do
+    it "should load the content type" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}})
+      @object.content_type.should == "application/json"
+    end
+
+    it "should load the body data" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => '{"foo":"bar"}'})
+      @object.raw_data.should be_present
+      @object.data.should be_present
+    end
+
+    it "should handle raw data properly" do
+      @object.should_not_receive(:deserialize) # optimize for the raw_data case, don't penalize people for using raw_data
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => body = '{"foo":"bar"}'})
+      @object.raw_data.should == body
+    end
+
+    it "should deserialize the body data" do
+      @object.should_receive(:deserialize).with("{}").and_return({})
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => "{}"})
+      @object.data.should == {}
+    end
+
+    it "should leave the object data unchanged if the response body is blank" do
+      @object.data = "Original data"
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"]}, :body => ""})
+      @object.data.should == "Original data"
+    end
+
+    it "should load the vclock from the headers" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], 'x-riak-vclock' => ["somereallylongbase64string=="]}, :body => "{}"})
+      @object.vclock.should == "somereallylongbase64string=="
+    end
+
+    it "should load links from the headers" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "link" => ['</riak/bar>; rel="up"']}, :body => "{}"})
+      @object.links.should have(1).item
+      @object.links.first.url.should == "/riak/bar"
+      @object.links.first.rel.should == "up"
+    end
+
+    it "should load the ETag from the headers" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "etag" => ["32748nvas83572934"]}, :body => "{}"})
+      @object.etag.should == "32748nvas83572934"
+    end
+
+    it "should load the modified date from the headers" do
+      time = Time.now
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "last-modified" => [time.httpdate]}, :body => "{}"})
+      @object.last_modified.to_s.should == time.to_s # bah, times are not equivalent unless equal
+    end
+
+    it "should load meta information from the headers" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "x-riak-meta-some-kind-of-robot" => ["for AWESOME"]}, :body => "{}"})
+      @object.meta["some-kind-of-robot"].should == ["for AWESOME"]
+    end
+
+    it "should parse the location header into the key when present" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/baz"]}})
+      @object.key.should == "baz"
+    end
+
+    it "should parse and escape the location header into the key when present" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/%5Bbaz%5D?vtag=1234"]}})
+      @object.key.should == "[baz]"
+    end
+
+    context "when the response code is 300 and the content-type is multipart/mixed" do
+      let(:http_response) { {:headers => {"content-type" => ["multipart/mixed; boundary=foo"]}, :code => 300 } }
+      let(:other_object) { Riak::RObject.new(@bucket, "bar2") }
+
+      it 'marks the object as in conflict' do
+        @backend.load_object(@object, http_response)
+        @object.should be_conflict
+      end
+
+      it 'attempts to resolve the conflict' do
+        @object.should respond_to(:attempt_conflict_resolution)
+        @object.should_receive(:attempt_conflict_resolution).and_return(other_object)
+        @backend.load_object(@object, http_response).should be(other_object)
+      end
+    end
+
+    it "should unescape the key given in the location header" do
+      @backend.load_object(@object, {:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/baz%20"]}})
+      @object.key.should == "baz "
+    end
+
+    describe "extracting siblings" do
+      before :each do
+        @backend.load_object(@object, {:headers => {"x-riak-vclock" => ["merged"], "content-type" => ["multipart/mixed; boundary=foo"]}, :code => 300, :body => "\n--foo\nContent-Type: text/plain\n\nbar\n--foo\nContent-Type: text/plain\n\nbaz\n--foo--\n"})
+      end
+
+      it "should extract the siblings" do
+        @object.should have(2).siblings
+        siblings = @object.siblings
+        siblings[0].data.should == "bar"
+        siblings[1].data.should == "baz"
+      end
+
+      it "should set the key on both siblings" do
+        @object.siblings.should be_all {|s| s.key == "bar" }
+      end
+
+      it "should set the vclock on both siblings to the merged vclock" do
+        @object.siblings.should be_all {|s| s.vclock == "merged" }
+      end
+    end
+  end
+
+  describe "headers used for storing the object" do    
+    it "should include the content type" do
+      @object.content_type = "application/json"
+      @backend.store_headers(@object)["Content-Type"].should == "application/json"
+    end
+
+    it "should include the vclock when present" do
+      @object.vclock = "123445678990"
+      @backend.store_headers(@object)["X-Riak-Vclock"].should == "123445678990"
+    end
+
+    it "should exclude the vclock when nil" do
+      @object.vclock = nil
+      @backend.store_headers(@object).should_not have_key("X-Riak-Vclock")
+    end
+
+    describe "when conditional PUTs are requested" do
+      before :each do
+        @object.prevent_stale_writes = true
+      end
+
+      it "should include an If-None-Match: * header" do
+        @backend.store_headers(@object).should have_key("If-None-Match")
+        @backend.store_headers(@object)["If-None-Match"].should == "*"
+      end
+
+      it "should include an If-Match header with the etag when an etag is present" do
+        @object.etag = "foobar"
+        @backend.store_headers(@object).should have_key("If-Match")
+        @backend.store_headers(@object)["If-Match"].should == @object.etag
+      end
+    end
+
+    describe "when links are defined" do
+      before :each do
+        @object.links << Riak::Link.new("/riak/foo/baz", "next")
+      end
+
+      it "should include a Link header with references to other objects" do
+        @backend.store_headers(@object).should have_key("Link")
+        @backend.store_headers(@object)["Link"].should include('</riak/foo/baz>; riaktag="next"')
+      end
+
+      it "should exclude the 'up' link to the bucket from the header" do
+        @object.links << Riak::Link.new("/riak/foo", "up")
+        @backend.store_headers(@object).should have_key("Link")
+        @backend.store_headers(@object)["Link"].should_not include('riaktag="up"')
+      end
+    end
+
+    it "should exclude the Link header when no links are present" do
+      @object.links = Set.new
+      @backend.store_headers(@object).should_not have_key("Link")
+    end
+
+    describe "when meta fields are present" do
+      before :each do
+        @object.meta = {"some-kind-of-robot" => true, "powers" => "for awesome", "cold-ones" => 10}
+      end
+
+      it "should include X-Riak-Meta-* headers for each meta key" do
+        @backend.store_headers(@object).should have_key("X-Riak-Meta-some-kind-of-robot")
+        @backend.store_headers(@object).should have_key("X-Riak-Meta-cold-ones")
+        @backend.store_headers(@object).should have_key("X-Riak-Meta-powers")
+      end
+
+      it "should turn non-string meta values into strings" do
+        @backend.store_headers(@object)["X-Riak-Meta-some-kind-of-robot"].should == "true"
+        @backend.store_headers(@object)["X-Riak-Meta-cold-ones"].should == "10"
+      end
+
+      it "should leave string meta values unchanged in the header" do
+        @backend.store_headers(@object)["X-Riak-Meta-powers"].should == "for awesome"
+      end
+    end
+  end
+
+  describe "headers used for reloading the object" do
+    it "should be blank when the etag and last_modified properties are blank" do
+      @object.etag.should be_blank
+      @object.last_modified.should be_blank
+      @backend.reload_headers(@object).should be_blank
+    end
+
+    it "should include the If-None-Match key when the etag is present" do
+      @object.etag = "etag!"
+      @backend.reload_headers(@object)['If-None-Match'].should == "etag!"
+    end
+
+    it "should include the If-Modified-Since header when the last_modified time is present" do
+      time = Time.now
+      @object.last_modified = time
+      @backend.reload_headers(@object)['If-Modified-Since'].should == time.httpdate
+    end
+  end
+end