ripple 0.5.0

data/spec/fixtures/multipart-blank.txt

@@ -0,0 +1,7 @@
+
+--73NmmA8dJxSB5nL2dVerpFIi8ze
+Content-Type: multipart/mixed; boundary=8fPXq9XfV15txMoV1IbA3hovEij
+
+--8fPXq9XfV15txMoV1IbA3hovEij--
+
+--73NmmA8dJxSB5nL2dVerpFIi8ze--

data/spec/fixtures/multipart-with-body.txt

@@ -0,0 +1,16 @@
+
+--5EiMOjuGavQ2IbXAqsJPLLfJNlA
+Content-Type: multipart/mixed; boundary=7extjTzvYIKVMVHowUiTn0LfvSs
+
+--7extjTzvYIKVMVHowUiTn0LfvSs
+X-Riak-Vclock: a85hYGBgyWDKBVHMr9s3ZzAlMuaxMtyZcPAIH1RYyObHDqiwxIZjcOG1M98chAq3bUQIz7SSFQEKM4FUbwMKZwEA
+Location: /raw/foo/baz
+Content-Type: text/plain
+Link: </raw/foo>; rel="up"
+Etag: 6JdI51eFrvv5lDwY6un7a2
+Last-Modified: Sat, 16 Jan 2010 22:13:44 GMT
+
+SCP sloooow....
+--7extjTzvYIKVMVHowUiTn0LfvSs--
+
+--5EiMOjuGavQ2IbXAqsJPLLfJNlA--

data/spec/riak/bucket_spec.rb

@@ -0,0 +1,141 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe Riak::Bucket do
+  before :each do
+    @client = Riak::Client.new
+    @bucket = Riak::Bucket.new(@client, "foo")
+  end
+
+  def do_load(overrides={})
+    @bucket.load({
+                   :body => '{"props":{"name":"foo","allow_mult":false,"big_vclock":50,"chash_keyfun":{"mod":"riak_util","fun":"chash_std_keyfun"},"linkfun":{"mod":"jiak_object","fun":"mapreduce_linkfun"},"n_val":3,"old_vclock":86400,"small_vclock":10,"young_vclock":20},"keys":["bar"]}',
+                   :headers => {
+                     "vary" => ["Accept-Encoding"],
+                     "server" => ["MochiWeb/1.1 WebMachine/1.5.1 (hack the charles gibson)"],
+                     "link" => ['</raw/foo/bar>; riaktag="contained"'],
+                     "date" => ["Tue, 12 Jan 2010 15:30:43 GMT"],
+                     "content-type" => ["application/json"],
+                     "content-length" => ["257"]
+                   }
+                 }.merge(overrides))
+  end
+
+
+  describe "when initializing" do
+    it "should require a client and a name" do
+      lambda { Riak::Bucket.new }.should raise_error
+      lambda { Riak::Bucket.new(@client) }.should raise_error
+      lambda { Riak::Bucket.new("foo") }.should raise_error
+      lambda { Riak::Bucket.new("foo", @client) }.should raise_error
+      lambda { Riak::Bucket.new(@client, "foo") }.should_not raise_error
+    end
+
+    it "should set the client and name attributes" do
+      bucket = Riak::Bucket.new(@client, "foo")
+      bucket.client.should == @client
+      bucket.name.should == "foo"
+    end
+  end
+
+  describe "when loading data from an HTTP response" do
+    it "should load the bucket properties from the response body" do
+      do_load
+      @bucket.props.should == {"name"=>"foo","allow_mult" => false,"big_vclock" => 50,"chash_keyfun" => {"mod" =>"riak_util","fun"=>"chash_std_keyfun"},"linkfun"=>{"mod"=>"jiak_object","fun"=>"mapreduce_linkfun"},"n_val"=>3,"old_vclock"=>86400,"small_vclock"=>10,"young_vclock"=>20}
+    end
+
+    it "should load the keys from the response body" do
+      do_load
+      @bucket.keys.should == ["bar"]
+    end
+
+    it "should raise an error for a response that is not JSON" do
+      lambda do
+        do_load(:headers => {"content-type" => ["text/plain"]})
+      end.should raise_error(Riak::InvalidResponse)
+    end
+
+    it "should unescape key names" do
+      do_load(:body => '{"keys":["foo", "bar%20baz"]}')
+      @bucket.keys.should == ["foo", "bar baz"]
+    end
+  end
+
+  describe "accessing keys" do
+    before :each do
+      @http = mock("HTTPBackend")
+      @client.stub!(:http).and_return(@http)
+    end
+
+    it "should load the keys if not present" do
+      @http.should_receive(:get).with(200, "/raw/", "foo", {:props => false}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar"]}'})
+      @bucket.keys.should == ["bar"]
+    end
+
+    it "should allow reloading of the keys" do
+      @http.should_receive(:get).with(200, "/raw/","foo", {:props => false}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar"]}'})
+      do_load # Ensures they're already loaded
+      @bucket.keys(:reload => true).should == ["bar"]
+    end
+
+    it "should allow streaming keys through block" do
+      # pending "Needs support in the raw_http_resource"
+      @http.should_receive(:get).with(200, "/raw/","foo", {:props => false}, {}).and_yield("{}").and_yield('{"keys":[]}').and_yield('{"keys":["bar"]}').and_yield('{"keys":["baz"]}')
+      all_keys = []
+      @bucket.keys do |list|
+        all_keys.concat(list)
+      end
+      all_keys.should == ["bar", "baz"]
+    end
+
+    it "should unescape key names" do
+      @http.should_receive(:get).with(200, "/raw/","foo", {:props => false}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar%20baz"]}'})
+      @bucket.keys.should == ["bar baz"]
+    end
+  end
+
+  describe "setting the bucket properties" do
+    before :each do
+      @http = mock("HTTPBackend")
+      @client.stub!(:http).and_return(@http)
+    end
+
+    it "should PUT the new properties to the bucket" do
+      @http.should_receive(:put).with(204, "/raw/","foo", '{"props":{"name":"foo"}}', {"Content-Type" => "application/json"}).and_return({:body => "", :headers => {}})
+      @bucket.props = { :name => "foo" }
+    end
+
+    it "should raise an error if an invalid property is given" do
+      lambda { @bucket.props = "blah" }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "fetching an object" do
+    before :each do
+      @http = mock("HTTPBackend")
+      @client.stub!(:http).and_return(@http)
+    end
+
+    it "should load the object from the server as a Riak::RObject" do
+      @http.should_receive(:get).with(200, "/raw/","foo", "db", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @bucket.get("db").should be_kind_of(Riak::RObject)
+    end
+
+    it "should use the given query parameters (for R value, etc)" do
+      @http.should_receive(:get).with(200, "/raw/","foo", "db", {:r => 2}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @bucket.get("db", :r => 2).should be_kind_of(Riak::RObject)
+    end
+  end
+end

data/spec/riak/client_spec.rb

@@ -0,0 +1,169 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe Riak::Client do
+  describe "when initializing" do
+    it "should default to the local interface on port 8098" do
+      client = Riak::Client.new
+      client.host.should == "127.0.0.1"
+      client.port.should == 8098
+    end
+
+    it "should accept a host" do
+      client = Riak::Client.new :host => "riak.basho.com"
+      client.host.should == "riak.basho.com"
+    end
+
+    it "should accept a port" do
+      client = Riak::Client.new :port => 9000
+      client.port.should == 9000
+    end
+
+    it "should accept a client ID" do
+      client = Riak::Client.new :client_id => "AAAAAA=="
+      client.client_id.should == "AAAAAA=="
+    end
+
+    it "should turn an integer client ID into a base64-encoded string" do
+      client = Riak::Client.new :client_id => 1
+      client.client_id.should == "AAAAAQ=="
+    end
+
+    it "should create a client ID if not specified" do
+      Riak::Client.new.client_id.should be_kind_of(String)
+    end
+
+    it "should accept a path prefix" do
+      client = Riak::Client.new(:prefix => "/jiak/")
+      client.prefix.should == "/jiak/"
+    end
+
+    it "should default the prefix to /raw/ if not specified" do
+      Riak::Client.new.prefix.should == "/raw/"
+    end
+
+    it "should accept a mapreduce path" do
+      client = Riak::Client.new(:mapred => "/mr")
+      client.mapred.should == "/mr"
+    end
+
+    it "should default the mapreduce path to /mapred if not specified" do
+      Riak::Client.new.mapred.should == "/mapred"
+    end
+  end
+
+  describe "reconfiguring" do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    describe "setting the host" do
+      it "should allow setting the host" do
+        @client.should respond_to(:host=)
+        @client.host = "riak.basho.com"
+        @client.host.should == "riak.basho.com"
+      end
+
+      it "should require the host to be an IP or hostname" do
+        [238472384972, ""].each do |invalid|
+          lambda { @client.host = invalid }.should raise_error(ArgumentError)
+        end
+        ["127.0.0.1", "10.0.100.5", "localhost", "otherhost.local", "riak.basho.com"].each do |valid|
+          lambda { @client.host = valid }.should_not raise_error
+        end
+      end
+    end
+
+    describe "setting the port" do
+      it "should allow setting the port" do
+        @client.should respond_to(:port=)
+        @client.port = 9000
+        @client.port.should == 9000
+      end
+
+      it "should require the port to be a valid number" do
+        [-1,65536,"foo"].each do |invalid|
+          lambda { @client.port = invalid }.should raise_error(ArgumentError)
+        end
+        [0,1,65535,8098].each do |valid|
+          lambda { @client.port = valid }.should_not raise_error
+        end
+      end
+    end
+
+    it "should allow setting the prefix (although we prefer the raw interface)" do
+      @client.should respond_to(:prefix=)
+      @client.prefix = "/another-prefix"
+      @client.prefix.should == "/another-prefix"
+    end
+
+    describe "setting the client id" do
+      it "should accept a string unmodified" do
+        @client.client_id = "foo"
+        @client.client_id.should == "foo"
+      end
+
+      it "should base64-encode an integer" do
+        @client.client_id = 1
+        @client.client_id.should == "AAAAAQ=="
+      end
+
+      it "should reject an integer equal to the maximum client id" do
+        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID }.should raise_error(ArgumentError)
+      end
+
+      it "should reject an integer larger than the maximum client id" do
+        lambda { @client.client_id = Riak::Client::MAX_CLIENT_ID + 1 }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "choosing an HTTP backend" do
+    before :each do
+      @client = Riak::Client.new
+    end
+
+    it "should choose the Curb backend if Curb is available" do
+      @client.should_receive(:require).with('curb').and_return(true)
+      @client.http.should be_instance_of(Riak::Client::CurbBackend)
+    end
+
+    it "should choose the Net::HTTP backend if Curb is unavailable" do
+      @client.should_receive(:require).with('curb').and_raise(LoadError)
+      @client.should_receive(:warn).and_return(true)
+      @client.http.should be_instance_of(Riak::Client::NetHTTPBackend)
+    end
+  end
+
+  describe "retrieving a bucket" do
+    before :each do
+      @client = Riak::Client.new
+      @http = mock(Riak::Client::HTTPBackend)
+      @client.stub!(:http).and_return(@http)
+      @payload = {:headers => {"content-type" => ["application/json"]}, :body => "{}"}
+      @http.stub!(:get).and_return(@payload)
+    end
+
+    it "should send a GET request to the bucket name and return a Riak::Bucket" do
+      @http.should_receive(:get).with(200, "/raw/", "foo", {}, {}).and_return(@payload)
+      @client.bucket("foo").should be_kind_of(Riak::Bucket)
+    end
+
+    it "should allow requesting bucket properties without the keys" do
+      @http.should_receive(:get).with(200, "/raw/", "foo", {:keys => false}, {}).and_return(@payload)
+      @client.bucket("foo", :keys => false)
+    end
+  end
+end

data/spec/riak/curb_backend_spec.rb

@@ -0,0 +1,50 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+begin
+  require 'curb'
+rescue LoadError
+  warn "Skipping CurbBackend specs, curb library not found."
+else
+  describe Riak::Client::CurbBackend do
+    def setup_http_mock(method, uri, options={})
+      method = method.to_s.upcase
+      uri = URI.parse(uri)
+      path = uri.path || "/"
+      query = uri.query || ""
+      status = options[:status] ? Array(options[:status]).first.to_i : 200
+      body = options[:body] || []
+      headers = options[:headers] || {}
+      headers['Content-Type'] ||= "text/plain"
+      $server.attach do |env|
+        env["REQUEST_METHOD"].should == method
+        env["PATH_INFO"].should == path
+        env["QUERY_STRING"].should == query
+        [status, headers, Array(body)]
+      end
+    end
+
+    before :each do
+      @client = Riak::Client.new(:port => 4000) # Point to our mock
+      @backend = Riak::Client::CurbBackend.new(@client)
+    end
+
+    it_should_behave_like "HTTP backend"
+
+    after :each do
+      $server.detach
+    end
+  end
+end

data/spec/riak/headers_spec.rb

@@ -0,0 +1,34 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+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\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\n")
+    h.to_hash.should == {"content-type" => ["text/plain"]}
+  end
+end

data/spec/riak/http_backend_spec.rb

@@ -0,0 +1,136 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe Riak::Client::HTTPBackend do
+  before :each do
+    @client = Riak::Client.new
+    @backend = Riak::Client::HTTPBackend.new(@client)
+  end
+
+  it "should take the Riak::Client when creating" do
+    lambda { Riak::Client::HTTPBackend.new(nil) }.should raise_error(ArgumentError)
+    lambda { Riak::Client::HTTPBackend.new(@client) }.should_not raise_error
+  end
+
+  it "should make the client accessible" do
+    @backend.client.should == @client
+  end
+
+  it "should generate default headers for requests based on the client settings" do
+    @client.client_id = "testing"
+    @backend.default_headers.should == {"X-Riak-ClientId" => "testing", "Accept" => "multipart/mixed, application/json;q=0.7, */*;q=0.5"}
+  end
+
+  it "should generate a root URI based on the client settings" do
+    @backend.root_uri.should be_kind_of(URI)
+    @backend.root_uri.to_s.should == "http://127.0.0.1:8098"
+  end
+
+  it "should compute a URI from a relative resource path" do
+    @backend.path("baz").should be_kind_of(URI)
+    @backend.path("foo").to_s.should == "http://127.0.0.1:8098/foo"
+    @backend.path("foo", "bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
+    @backend.path("/foo/bar").to_s.should == "http://127.0.0.1:8098/foo/bar"
+  end
+
+  it "should escape appropriate characters in a relative resource path" do
+    @backend.path("foo bar").to_s.should == "http://127.0.0.1:8098/foo%20bar"
+    @backend.path("foo", "bar", {"param" => "a string"}).to_s.should == "http://127.0.0.1:8098/foo/bar?param=a+string"
+  end
+
+  it "should compute a URI from a relative resource path with a hash of query parameters" do
+    @backend.path("baz", :r => 2).to_s.should == "http://127.0.0.1:8098/baz?r=2"
+  end
+
+  it "should raise an error if a resource path is too short" do
+    lambda { @backend.verify_path!(["/raw/"]) }.should raise_error(ArgumentError)
+    lambda { @backend.verify_path!(["/raw/", "foo"]) }.should_not raise_error
+    lambda { @backend.verify_path!(["/mapred"]) }.should_not raise_error
+  end
+
+  describe "verify_path_and_body!" do
+    it "should separate the path and body from given arguments" do
+      uri, data = @backend.verify_path_and_body!(["/raw/", "foo", "This is the body."])
+      uri.should == ["/raw/", "foo"]
+      data.should == "This is the body."
+    end
+
+    it "should raise an error if the body is not a string or IO" do
+      lambda { @backend.verify_path_and_body!(["/raw/", "foo", nil]) }.should raise_error(ArgumentError)
+      lambda { @backend.verify_path_and_body!(["/raw/", "foo", File.open("spec/fixtures/cat.jpg")]) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should raise an error if a body is not given" do
+      lambda { @backend.verify_path_and_body!(["/raw/", "foo"])}.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if a path is not given" do
+      lambda { @backend.verify_path_and_body!(["/raw/"])}.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe "detecting valid response codes" do
+    it "should accept strings or integers for either argument" do
+      @backend.should be_valid_response("300", "300")
+      @backend.should be_valid_response(300, "300")
+      @backend.should be_valid_response("300", 300)
+    end
+
+    it "should accept an array of strings or integers for the expected code" do
+      @backend.should be_valid_response([200,304], "200")
+      @backend.should be_valid_response(["200",304], "200")
+      @backend.should be_valid_response([200,"304"], "200")
+      @backend.should be_valid_response(["200","304"], "200")
+      @backend.should be_valid_response([200,304], 200)
+    end
+
+    it "should be false when none of the response codes match" do
+      @backend.should_not be_valid_response(200, 404)
+      @backend.should_not be_valid_response(["200","304"], 404)
+      @backend.should_not be_valid_response([200,304], 404)
+    end
+  end
+
+  describe "detecting whether a body should be returned" do
+    it "should be false when the method is :head" do
+      @backend.should_not be_return_body(:head, 200, false)
+    end
+
+    it "should be false when the response code is 204, 205, or 304" do
+      @backend.should_not be_return_body(:get, 204, false)
+      @backend.should_not be_return_body(:get, 205, false)
+      @backend.should_not be_return_body(:get, 304, false)
+    end
+
+    it "should be false when a streaming block was passed" do
+      @backend.should_not be_return_body(:get, 200, true)
+    end
+
+    it "should be true when the method is not head, a code other than 204, 205, or 304 was given, and there was no streaming block" do
+      [:get, :put, :post, :delete].each do |method|
+        [100,101,200,201,202,203,206,300,301,302,303,305,307,400,401,
+         402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,
+         500,501,502,503,504,505].each do |code|
+          @backend.should be_return_body(method, code, false)
+          @backend.should be_return_body(method, code.to_s, false)
+        end
+      end
+    end
+  end
+  
+  it "should force subclasses to implement the perform method" do
+    lambda { @backend.send(:perform, :get, "/foo", {}, 200) }.should raise_error(NotImplementedError)
+  end
+end