ripple 0.5.1 → 0.6.0

data/lib/ripple/document.rb

@@ -28,15 +28,15 @@ module Ripple
   #     property :body,    String
   #   end
   #
-  #   email = Email.find("37458abc752f8413e")  # GET /raw/emails/37458abc752f8413e
+  #   email = Email.find("37458abc752f8413e")  # GET /riak/emails/37458abc752f8413e
   #   email.from = "someone@nowhere.net"
-  #   email.save                               # PUT /raw/emails/37458abc752f8413e
+  #   email.save                               # PUT /riak/emails/37458abc752f8413e
   #
   #   reply = Email.new
   #   reply.from = "justin@bashoooo.com"
   #   reply.to   = "sean@geeemail.com"
   #   reply.body = "Riak is a good fit for scalable Ruby apps."
-  #   reply.save                               # POST /raw/emails (Riak-assigned key)
+  #   reply.save                               # POST /riak/emails (Riak-assigned key)
   #
   module Document
     extend ActiveSupport::Concern
@@ -48,6 +48,7 @@ module Ripple
     autoload :Persistence
     autoload :Properties
     autoload :Property, "ripple/document/properties"
+    autoload :Timestamps
     autoload :Validations
 
     included do

data/lib/ripple/document/attribute_methods.rb

@@ -64,7 +64,7 @@ module Ripple
         # Mass assign the document's attributes.
         # @param [Hash] attrs the attributes to assign
         def attributes=(attrs)
-          raise ArgumentError, "value of attributes must be a Hash" unless Hash === attrs
+          raise ArgumentError, t('attribute_hash') unless Hash === attrs
           attrs.each do |k,v|
             if respond_to?("#{k}=")
               __send__("#{k}=",v)

data/lib/ripple/document/finders.rb

@@ -46,13 +46,14 @@ module Ripple
         #   @return [Array<Document>] all found documents in the bucket
         # @overload all() {|doc| ... }
         #   Stream all documents in the bucket through the block.
-        #   TODO: Make this work with the CurbBackend (currently single-request oriented).
         #   @yield [Document] doc a found document
         def all
           if block_given?
-            bucket.keys do |key|
-              obj = find_one(key)
-              yield obj if obj
+            bucket.keys do |keys|
+              keys.each do |key|
+                obj = find_one(key)
+                yield obj if obj
+              end
             end
             []
           else

data/lib/ripple/document/timestamps.rb

@@ -0,0 +1,22 @@
+module Ripple
+  module Document
+    module Timestamps
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def timestamps!
+          property :created_at, Time, :default => proc { Time.now.utc }
+          property :updated_at, Time
+          before_save :touch
+        end
+      end
+
+      module InstanceMethods
+        def touch
+          self.updated_at = Time.now.utc
+        end
+      end
+
+    end
+  end
+end

data/lib/ripple/embedded_document.rb

@@ -26,6 +26,7 @@ module Ripple
       extend Ripple::Document::Properties
       include Persistence
       include Ripple::Document::AttributeMethods
+      include Ripple::Document::Timestamps
       include Ripple::Document::Validations
     end
 

data/lib/ripple/locale/en.yml

@@ -13,4 +13,5 @@
 #    limitations under the License.
 en:
   ripple:
-    property_type_mismatch: "Cannot cast {{value}} into a {{class}}"
+    property_type_mismatch: "Cannot cast {{value}} into a {{class}}"
+    attribute_hash: "value of attributes must be a Hash"

data/ripple.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ripple}
-  s.version = "0.5.1"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sean Cribbs"]
-  s.date = %q{2010-02-22}
+  s.date = %q{2010-03-05}
   s.description = %q{ripple is a rich Ruby client for Riak, Basho's distributed database.  It includes all the basics of accessing and manipulating Riak buckets and objects, and an object mapper library for building a rich domain on top of Riak.}
   s.email = %q{seancribbs@gmail.com}
   s.extra_rdoc_files = [
@@ -39,6 +39,7 @@ Gem::Specification.new do |s|
      "lib/riak/map_reduce.rb",
      "lib/riak/map_reduce_error.rb",
      "lib/riak/robject.rb",
+     "lib/riak/util/fiber1.8.rb",
      "lib/riak/util/headers.rb",
      "lib/riak/util/multipart.rb",
      "lib/riak/util/translation.rb",
@@ -56,6 +57,7 @@ Gem::Specification.new do |s|
      "lib/ripple/document/persistence.rb",
      "lib/ripple/document/persistence/callbacks.rb",
      "lib/ripple/document/properties.rb",
+     "lib/ripple/document/timestamps.rb",
      "lib/ripple/document/validations.rb",
      "lib/ripple/embedded_document.rb",
      "lib/ripple/embedded_document/persistence.rb",
@@ -87,6 +89,7 @@ Gem::Specification.new do |s|
      "spec/ripple/persistence_spec.rb",
      "spec/ripple/properties_spec.rb",
      "spec/ripple/ripple_spec.rb",
+     "spec/ripple/timestamps_spec.rb",
      "spec/ripple/validations_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
@@ -120,6 +123,7 @@ Gem::Specification.new do |s|
      "spec/ripple/persistence_spec.rb",
      "spec/ripple/properties_spec.rb",
      "spec/ripple/ripple_spec.rb",
+     "spec/ripple/timestamps_spec.rb",
      "spec/ripple/validations_spec.rb",
      "spec/spec_helper.rb",
      "spec/support/http_backend_implementation_examples.rb",

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

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

data/spec/riak/bucket_spec.rb

@@ -25,7 +25,7 @@ describe Riak::Bucket do
                    :headers => {
                      "vary" => ["Accept-Encoding"],
                      "server" => ["MochiWeb/1.1 WebMachine/1.5.1 (hack the charles gibson)"],
-                     "link" => ['</raw/foo/bar>; riaktag="contained"'],
+                     "link" => ['</riak/foo/bar>; riaktag="contained"'],
                      "date" => ["Tue, 12 Jan 2010 15:30:43 GMT"],
                      "content-type" => ["application/json"],
                      "content-length" => ["257"]
@@ -80,19 +80,19 @@ describe Riak::Bucket do
     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"]}'})
+      @http.should_receive(:get).with(200, "/riak/", "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"]}'})
+      @http.should_receive(:get).with(200, "/riak/","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"]}')
+      @http.should_receive(:get).with(200, "/riak/","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)
@@ -101,7 +101,7 @@ describe Riak::Bucket do
     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"]}'})
+      @http.should_receive(:get).with(200, "/riak/","foo", {:props => false}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar%20baz"]}'})
       @bucket.keys.should == ["bar baz"]
     end
   end
@@ -113,7 +113,7 @@ describe Riak::Bucket do
     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 => {}})
+      @http.should_receive(:put).with(204, "/riak/","foo", '{"props":{"name":"foo"}}', {"Content-Type" => "application/json"}).and_return({:body => "", :headers => {}})
       @bucket.props = { :name => "foo" }
     end
 
@@ -129,13 +129,84 @@ describe Riak::Bucket do
     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"}'})
+      @http.should_receive(:get).with(200, "/riak/","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"}'})
+      @http.should_receive(:get).with(200, "/riak/","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
+
+    it "should allow 300 responses if allow_mult is set" do
+      @bucket.instance_variable_set(:@props, {'allow_mult' => true})
+      @http.should_receive(:get).with([200,300], "/riak/","foo", "db", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      @bucket.get('db')
+    end
+  end
+
+  describe "creating a new blank object" do
+    it "should instantiate the object with the given key, default to JSON" do
+      obj = @bucket.new('bar')
+      obj.should be_kind_of(Riak::RObject)
+      obj.key.should == 'bar'
+      obj.content_type.should == 'application/json'
+    end
+  end
+
+  describe "fetching or creating a new object" do
+    before :each do
+      @http = mock("HTTPBackend")
+      @client.stub!(:http).and_return(@http)
+    end
+
+    it "should return the existing object if present" do
+      @http.should_receive(:get).with(200, "/riak/","foo", "db", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
+      obj = @bucket.get_or_new('db')
+      obj.key.should == 'db'
+      obj.data['name'].should == "Riak"
+    end
+
+    it "should create a new blank object if the key does not exist" do
+      @http.should_receive(:get).and_raise(Riak::FailedRequest.new(:get, 200, 404, {}, "File not found"))
+      obj = @bucket.get_or_new('db')
+      obj.key.should == 'db'
+      obj.data.should be_blank
+    end
+
+    it "should bubble up non-ok non-missing errors" do
+      @http.should_receive(:get).and_raise(Riak::FailedRequest.new(:get, 200, 500, {}, "File not found"))
+      lambda { @bucket.get_or_new('db') }.should raise_error(Riak::FailedRequest)
+    end
+  end
+
+  describe "get/set allow_mult property" do
+    before :each do
+      do_load
+    end
+
+    it "should extract the allow_mult property" do
+      @bucket.allow_mult.should be_false
+    end
+
+    it "should set the allow_mult property" do
+      @bucket.should_receive(:props=).with(hash_including('allow_mult' => true))
+      @bucket.allow_mult = true
+    end
+  end
+
+  describe "get/set the N value" do
+    before :each do
+      do_load
+    end
+
+    it "should extract the N value" do
+      @bucket.n_value.should == 3
+    end
+
+    it "should set the N value" do
+      @bucket.should_receive(:props=).with(hash_including('n_val' => 1))
+      @bucket.n_value = 1
+    end
   end
 end

data/spec/riak/client_spec.rb

@@ -50,8 +50,8 @@ describe Riak::Client do
       client.prefix.should == "/jiak/"
     end
 
-    it "should default the prefix to /raw/ if not specified" do
-      Riak::Client.new.prefix.should == "/raw/"
+    it "should default the prefix to /riak/ if not specified" do
+      Riak::Client.new.prefix.should == "/riak/"
     end
 
     it "should accept a mapreduce path" do
@@ -157,12 +157,12 @@ describe Riak::Client do
     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)
+      @http.should_receive(:get).with(200, "/riak/", "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)
+      @http.should_receive(:get).with(200, "/riak/", "foo", {:keys => false}, {}).and_return(@payload)
       @client.bucket("foo", :keys => false)
     end
   end

data/spec/riak/http_backend_spec.rb

@@ -55,29 +55,29 @@ describe Riak::Client::HTTPBackend do
   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!(["/riak/"]) }.should raise_error(ArgumentError)
+    lambda { @backend.verify_path!(["/riak/", "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"]
+      uri, data = @backend.verify_path_and_body!(["/riak/", "foo", "This is the body."])
+      uri.should == ["/riak/", "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)
+      lambda { @backend.verify_path_and_body!(["/riak/", "foo", nil]) }.should raise_error(ArgumentError)
+      lambda { @backend.verify_path_and_body!(["/riak/", "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)
+      lambda { @backend.verify_path_and_body!(["/riak/", "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)
+      lambda { @backend.verify_path_and_body!(["/riak/"])}.should raise_error(ArgumentError)
     end
   end
   

data/spec/riak/link_spec.rb

@@ -16,31 +16,31 @@ require File.expand_path("../spec_helper", File.dirname(__FILE__))
 describe Riak::Link do
   describe "parsing a link header" do
     it "should create Link objects from the data" do
-      result = Riak::Link.parse('</raw/foo/bar>; rel="tag", </raw/foo>; rel="up"')
+      result = Riak::Link.parse('</riak/foo/bar>; rel="tag", </riak/foo>; rel="up"')
       result.should be_kind_of(Array)
       result.should be_all {|i| Riak::Link === i }
     end
 
     it "should set the bucket, key, url and rel parameters properly" do
-      result = Riak::Link.parse('</raw/foo/bar>; riaktag="tag", </raw/foo>; rel="up"')
-      result[0].url.should == "/raw/foo/bar"
+      result = Riak::Link.parse('</riak/foo/bar>; riaktag="tag", </riak/foo>; rel="up"')
+      result[0].url.should == "/riak/foo/bar"
       result[0].bucket.should == "foo"
       result[0].key.should == "bar"
       result[0].rel.should == "tag"
-      result[1].url.should == "/raw/foo"
+      result[1].url.should == "/riak/foo"
       result[1].bucket.should == "foo"
       result[1].key.should == nil
       result[1].rel.should == "up"
     end
     
     it "should set url properly, and set bucket and key to nil for non-Riak links" do
-      result = Riak::Link.parse('<http://www.example.com/123.html>; riaktag="tag", </raw/foo>; rel="up"')
+      result = Riak::Link.parse('<http://www.example.com/123.html>; riaktag="tag", </riak/foo>; rel="up"')
       result[0].url.should == "http://www.example.com/123.html"
       result[0].bucket.should == nil
       result[0].key.should == nil
       result[0].rel.should == "tag"
 
-      result = Riak::Link.parse('<http://www.example.com/>; riaktag="tag", </raw/foo>; rel="up"')
+      result = Riak::Link.parse('<http://www.example.com/>; riaktag="tag", </riak/foo>; rel="up"')
       result[0].url.should == "http://www.example.com/"
       result[0].bucket.should == nil
       result[0].key.should == nil
@@ -49,18 +49,18 @@ describe Riak::Link do
   end
 
   it "should convert to a string appropriate for use in the Link header" do
-    Riak::Link.new("/raw/foo", "up").to_s.should == '</raw/foo>; riaktag="up"'
-    Riak::Link.new("/raw/foo/bar", "next").to_s.should == '</raw/foo/bar>; riaktag="next"'
+    Riak::Link.new("/riak/foo", "up").to_s.should == '</riak/foo>; riaktag="up"'
+    Riak::Link.new("/riak/foo/bar", "next").to_s.should == '</riak/foo/bar>; riaktag="next"'
   end
 
   it "should convert to a walk spec when pointing to an object" do
-    Riak::Link.new("/raw/foo/bar", "next").to_walk_spec.to_s.should == "foo,next,_"
-    lambda { Riak::Link.new("/raw/foo", "up").to_walk_spec }.should raise_error
+    Riak::Link.new("/riak/foo/bar", "next").to_walk_spec.to_s.should == "foo,next,_"
+    lambda { Riak::Link.new("/riak/foo", "up").to_walk_spec }.should raise_error
   end
 
   it "should be equivalent to a link with the same url and rel" do
-    one = Riak::Link.new("/raw/foo/bar", "next")
-    two = Riak::Link.new("/raw/foo/bar", "next")
+    one = Riak::Link.new("/riak/foo/bar", "next")
+    two = Riak::Link.new("/riak/foo/bar", "next")
     one.should == two
     [one].should include(two)
     [two].should include(one)

data/spec/riak/map_reduce_spec.rb

@@ -173,6 +173,11 @@ describe Riak::MapReduce do
       @mr.add("foo","bar",1000).add("foo","baz")
       @mr.to_json.should include('"inputs":[["foo","bar",1000],["foo","baz"]]')
     end
+
+    it "should add the timeout value when set" do
+      @mr.timeout(50000)
+      @mr.to_json.should include('"timeout":50000')
+    end
   end
 
   describe "executing the map reduce job" do

data/spec/riak/object_spec.rb

@@ -32,13 +32,19 @@ describe Riak::RObject do
 
     it "should initialize the links to an empty array" do
       @object = Riak::RObject.new(@bucket, "bar")
-      @object.links.should == []
+      @object.links.should == Set.new
     end
 
     it "should initialize the meta to an empty hash" do
       @object = Riak::RObject.new(@bucket, "bar")
       @object.meta.should == {}
     end
+
+    it "should yield itself to a given block" do
+      Riak::RObject.new(@bucket, "bar") do |r|
+        r.key.should == "bar"
+      end
+    end
   end
 
   describe "serialization" do
@@ -165,9 +171,9 @@ describe Riak::RObject do
     end
 
     it "should load links from the headers" do
-      @object.load({:headers => {"content-type" => ["application/json"], "link" => ['</raw/bar>; rel="up"']}, :body => "{}"})
+      @object.load({:headers => {"content-type" => ["application/json"], "link" => ['</riak/bar>; rel="up"']}, :body => "{}"})
       @object.links.should have(1).item
-      @object.links.first.url.should == "/raw/bar"
+      @object.links.first.url.should == "/riak/bar"
       @object.links.first.rel.should == "up"
     end
 
@@ -188,9 +194,35 @@ describe Riak::RObject do
     end
 
     it "should parse the location header into the key when present" do
-      @object.load({:headers => {"content-type" => ["application/json"], "location" => ["/raw/foo/baz"]}})
+      @object.load({:headers => {"content-type" => ["application/json"], "location" => ["/riak/foo/baz"]}})
       @object.key.should == "baz"
     end
+
+    it "should be in conflict when the response code is 300 and the content-type is multipart/mixed" do
+      @object.load({:headers => {"content-type" => ["multipart/mixed; boundary=foo"]}, :code => 300 })
+      @object.should be_conflict
+    end
+  end
+
+  describe "extracting siblings" do
+    before :each do
+      @object = Riak::RObject.new(@bucket, "bar").load({: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
 
   describe "headers used for storing the object" do
@@ -215,16 +247,16 @@ describe Riak::RObject do
 
     describe "when links are defined" do
       before :each do
-        @object.links = [Riak::Link.new("/raw/foo/baz", "next")]
+        @object.links = [Riak::Link.new("/riak/foo/baz", "next")]
       end
 
       it "should include a Link header with references to other objects" do
         @object.store_headers.should have_key("Link")
-        @object.store_headers["Link"].should include('</raw/foo/baz>; riaktag="next"')
+        @object.store_headers["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("/raw/foo", "up")
+        @object.links << Riak::Link.new("/riak/foo", "up")
         @object.store_headers.should have_key("Link")
         @object.store_headers["Link"].should_not include('riaktag="up"')
       end
@@ -297,14 +329,14 @@ describe Riak::RObject do
 
     describe "when the object has no key" do
       it "should issue a POST request to the bucket, and update the object properties (returning the body by default)" do
-        @http.should_receive(:post).with(201, "/raw/", "foo", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/raw/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
+        @http.should_receive(:post).with(201, "/riak/", "foo", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
         @object.store
         @object.key.should == "somereallylongstring"
         @object.vclock.should == "areallylonghashvalue"
       end
 
       it "should include persistence-tuning parameters in the query string" do
-        @http.should_receive(:post).with(201, "/raw/", "foo", {:dw => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/raw/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
+        @http.should_receive(:post).with(201, "/riak/", "foo", {:dw => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 201})
         @object.store(:dw => 2)
       end
     end
@@ -315,14 +347,14 @@ describe Riak::RObject do
       end
 
       it "should issue a PUT request to the bucket, and update the object properties (returning the body by default)" do
-        @http.should_receive(:put).with([200,204], "/raw/", "foo/bar", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/raw/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
+        @http.should_receive(:put).with([200,204], "/riak/", "foo/bar", {:returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
         @object.store
         @object.key.should == "somereallylongstring"
         @object.vclock.should == "areallylonghashvalue"
       end
 
       it "should include persistence-tuning parameters in the query string" do
-        @http.should_receive(:put).with([200,204], "/raw/", "foo/bar", {:dw => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/raw/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
+        @http.should_receive(:put).with([200,204], "/riak/", "foo/bar", {:dw => 2, :returnbody => true}, "This is some text.", @headers).and_return({:headers => {'location' => ["/riak/foo/somereallylongstring"], "x-riak-vclock" => ["areallylonghashvalue"]}, :code => 204})
         @object.store(:dw => 2)
       end
     end
@@ -357,7 +389,7 @@ describe Riak::RObject do
     it "should pass along the reload_headers" do
       @headers = {"If-None-Match" => "etag"}
       @object.should_receive(:reload_headers).and_return(@headers)
-      @http.should_receive(:get).with([200,304], "/raw/", "foo", "bar", {}, @headers).and_return({:code => 304})
+      @http.should_receive(:get).with([200,304], "/riak/", "foo", "bar", {}, @headers).and_return({:code => 304})
       @object.reload
     end
 
@@ -372,6 +404,12 @@ describe Riak::RObject do
       @object.should_not_receive(:load)
       lambda { @object.reload }.should raise_error(Riak::FailedRequest)
     end
+
+    it "should include 300 in valid responses if the bucket has allow_mult set" do
+      @object.bucket.should_receive(:allow_mult).and_return(true)
+      @http.should_receive(:get).with([200,300,304], "/riak/", "foo", "bar", {}, {}).and_return({:code => 304})
+      @object.reload
+    end
   end
 
   describe "walking from the object to linked objects" do
@@ -384,7 +422,7 @@ describe Riak::RObject do
     end
 
     it "should issue a GET request to the given walk spec" do
-      @http.should_receive(:get).with(200, "/raw/", "foo", "bar", "_,next,1").and_return(:headers => {"content-type" => ["multipart/mixed; boundary=12345"]}, :body => "\n--12345\nContent-Type: multipart/mixed; boundary=09876\n\n--09876--\n\n--12345--\n")
+      @http.should_receive(:get).with(200, "/riak/", "foo", "bar", "_,next,1").and_return(:headers => {"content-type" => ["multipart/mixed; boundary=12345"]}, :body => "\n--12345\nContent-Type: multipart/mixed; boundary=09876\n\n--09876--\n\n--12345--\n")
       @object.walk(nil,"next",true)
     end
 
@@ -415,7 +453,7 @@ describe Riak::RObject do
     end
 
     it "should make a DELETE request to the Riak server and freeze the object" do
-      @http.should_receive(:delete).with([204,404], "/raw/", "foo", "bar").and_return({:code => 204, :headers => {}})
+      @http.should_receive(:delete).with([204,404], "/riak/", "foo", "bar").and_return({:code => 204, :headers => {}})
       @object.delete
       @object.should be_frozen
     end
@@ -434,11 +472,11 @@ describe Riak::RObject do
 
   it "should convert to a link having the same url and an empty tag" do
     @object = Riak::RObject.new(@bucket, "bar")
-    @object.to_link.should == Riak::Link.new("/raw/foo/bar", nil)
+    @object.to_link.should == Riak::Link.new("/riak/foo/bar", nil)
   end
 
   it "should convert to a link having the same url and a supplied tag" do
     @object = Riak::RObject.new(@bucket, "bar")
-    @object.to_link("next").should == Riak::Link.new("/raw/foo/bar", "next")
+    @object.to_link("next").should == Riak::Link.new("/riak/foo/bar", "next")
   end
 end