ripple 0.6.1 → 0.7.0

data/spec/fixtures/multipart-blank.txt

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

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

@@ -1,16 +0,0 @@
-
---5EiMOjuGavQ2IbXAqsJPLLfJNlA
-Content-Type: multipart/mixed; boundary=7extjTzvYIKVMVHowUiTn0LfvSs
-
---7extjTzvYIKVMVHowUiTn0LfvSs
-X-Riak-Vclock: a85hYGBgyWDKBVHMr9s3ZzAlMuaxMtyZcPAIH1RYyObHDqiwxIZjcOG1M98chAq3bUQIz7SSFQEKM4FUbwMKZwEA
-Location: /riak/foo/baz
-Content-Type: text/plain
-Link: </riak/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

@@ -1,230 +0,0 @@
-# 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" => ['</riak/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, "/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, "/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, "/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)
-      end
-      all_keys.should == ["bar", "baz"]
-    end
-
-    it "should unescape key names" do
-      @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
-
-    it "should escape the bucket name" do
-      @bucket.instance_variable_set :@name, "unescaped "
-      @http.should_receive(:get).with(200, "/riak/","unescaped%20", {:props => false}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"keys":["bar"]}'})
-      @bucket.keys.should == ["bar"]
-    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, "/riak/","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
-
-    it "should escape the bucket name" do
-      @bucket.instance_variable_set :@name, "foo bar"
-      @http.should_receive(:put).with(204, "/riak/","foo%20bar", '{"props":{"n_val":2}}', {"Content-Type" => "application/json"}).and_return({:body => "", :headers => {}})
-      @bucket.props = {:n_val => 2}
-    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, "/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, "/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
-
-    it "should escape the bucket and key names" do
-      @bucket.instance_variable_set(:@name, "foo ")
-      @http.should_receive(:get).with(200, "/riak/","foo%20", "%20bar", {}, {}).and_return({:headers => {"content-type" => ["application/json"]}, :body => '{"name":"Riak","company":"Basho"}'})
-      @bucket.get(' bar')
-    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

@@ -1,174 +0,0 @@
-# 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 /riak/ if not specified" do
-      Riak::Client.new.prefix.should == "/riak/"
-    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, "/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, "/riak/", "foo", {:keys => false}, {}).and_return(@payload)
-      @client.bucket("foo", :keys => false)
-    end
-
-    it "should escape bucket names with invalid characters" do
-      @http.should_receive(:get).with(200, "/riak/", "foo%2Fbar%20", {:keys => false}, {}).and_return(@payload)
-      @client.bucket("foo/bar ", :keys => false)
-    end
-  end
-end

data/spec/riak/curb_backend_spec.rb

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