ripple 0.5.0

data/spec/ripple/persistence_spec.rb

@@ -0,0 +1,89 @@
+# 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__)
+
+describe Ripple::Document::Persistence do
+  before :all do
+    class Widget
+      include Ripple::Document
+      property :size, Integer
+      property :name, String, :default => "widget"
+    end
+  end
+
+  before :each do
+    @http = mock("HTTP Backend")
+    @client = Ripple.client
+    @client.stub!(:http).and_return(@http)
+    @bucket = Riak::Bucket.new(@client, "widgets")
+    @client.stub!(:[]).and_return(@bucket)
+    @widget = Widget.new(:size => 1000)
+  end
+
+  it "should save a new object to Riak" do
+    json = @widget.attributes.merge("_type" => "Widget").to_json
+    @http.should_receive(:post).with(201, "/raw/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @widget.save
+    @widget.key.should == "new_widget"
+    @widget.should_not be_new_record
+    @widget.changes.should be_blank
+  end
+
+  it "should reload a saved object" do
+    json = @widget.attributes.merge("_type" => "Widget").to_json
+    @http.should_receive(:post).with(201, "/raw/", "widgets", an_instance_of(Hash), json, hash_including("Content-Type" => "application/json")).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @widget.save
+    @http.should_receive(:get).and_return(:code => 200, :headers => {'content-type' => ["application/json"]}, :body => '{"name":"spring","size":10}')
+    @widget.reload
+    @widget.changes.should be_blank
+    @widget.name.should == "spring"
+    @widget.size.should == 10
+  end
+
+  it "should destroy a saved object" do
+    @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+    @widget.save
+    @http.should_receive(:delete).and_return(:code => 204, :headers => {})
+    @widget.destroy.should be_true
+    @widget.should be_frozen
+  end
+
+  it "should freeze an unsaved object when destroying" do
+    @http.should_not_receive(:delete)
+    @widget.destroy.should be_true
+    @widget.should be_frozen
+  end
+
+  describe "when storing a class using single-bucket inheritance" do
+    before :all do
+      class Cog < Widget; property :name, String, :default => "cog"; end
+      @cog = Cog.new(:size => 1000)
+    end
+
+    it "should store the _type field as the class name" do
+      json = @cog.attributes.merge("_type" => "Cog").to_json
+      @http.should_receive(:post).and_return(:code => 201, :headers => {'location' => ["/raw/widgets/new_widget"]})
+      @cog.save
+      @cog.should_not be_new_record
+    end
+
+    after :all do
+      Object.send(:remove_const, :Cog)
+    end
+  end
+
+  after :all do
+    Object.send(:remove_const, :Widget)
+  end
+end

data/spec/ripple/properties_spec.rb

@@ -0,0 +1,195 @@
+# 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__)
+
+describe Ripple::Document::Properties do
+  before :all do
+    class Email; include Ripple::Document; end
+  end
+
+  it "should make the model class have a property definition method" do
+    Email.should respond_to(:property)
+  end
+
+  it "should add properties to the class via the property method" do
+    Email.property :from, String
+    Email.properties.should include(:from)
+  end
+
+  it "should make the model class have a collection of properties" do
+    Email.should respond_to(:properties)
+    Email.properties.should be_kind_of(Hash)
+  end
+
+  it "should make subclasses inherit properties from the parent class" do
+    Email.properties[:foo] = "bar"
+    class Forward < Email; end
+    Forward.properties[:foo].should == "bar"
+  end
+
+
+  after :all do
+    Object.send(:remove_const, :Email)
+  end
+end
+
+describe Ripple::Document::Property do
+  it "should have a key symbol" do
+    prop = Ripple::Document::Property.new('foo', String)
+    prop.should respond_to(:key)
+    prop.key.should == :foo
+  end
+
+  it "should have a type" do
+    prop = Ripple::Document::Property.new('foo', String)
+    prop.should respond_to(:type)
+    prop.type.should == String
+  end
+
+  it "should capture extra options" do
+    prop = Ripple::Document::Property.new('foo', String, 'default' => "bar")
+    prop.should respond_to(:options)
+    prop.options.should == {:default => "bar"}
+  end
+
+  it "should expose validation options" do
+    prop = Ripple::Document::Property.new('foo', String, 'default' => "bar", :presence => true)
+    prop.validation_options.should == {:presence => true}
+  end
+
+  describe "default value" do
+    it "should be nil when not specified" do
+      prop = Ripple::Document::Property.new('foo', String)
+      prop.default.should be_nil
+    end
+
+    it "should allow literal values" do
+      prop = Ripple::Document::Property.new('foo', String, :default => "bar")
+      prop.default.should == "bar"
+    end
+
+    it "should cast to the proper type" do
+      prop = Ripple::Document::Property.new('foo', String, :default => :bar)
+      prop.default.should == "bar"
+    end
+
+    it "should allow lambdas for deferred evaluation" do
+      prop = Ripple::Document::Property.new('foo', String, :default => lambda { "bar" })
+      prop.default.should == "bar"
+    end
+  end
+
+  describe "casting a value" do
+    describe "when type is Boolean" do
+      before :each do
+        @prop = Ripple::Document::Property.new('foo', Boolean)
+      end
+
+      [0, 0.0, "", [], false, "f", "FALSE"].each do |v|
+        it "should cast #{v.inspect} to false" do
+          @prop.type_cast(v).should == false
+        end
+      end
+
+      [1, 1.0, "true", "1", [1], true, "t", "TRUE"].each do |v|
+        it "should cast #{v.inspect} to true" do
+          @prop.type_cast(v).should == true
+        end
+      end
+
+      it "should not cast nil" do
+        @prop.type_cast(nil).should be_nil
+      end
+    end
+
+    describe "when type is String" do
+      before :each do
+        @prop = Ripple::Document::Property.new('foo', String)
+      end
+
+      it "should cast anything to a string using to_s" do
+        @prop.type_cast("s").should == "s"
+        @prop.type_cast(1).should == "1"
+        @prop.type_cast(true).should == "true"
+        @prop.type_cast([]).should == ""
+      end
+    end
+
+    describe "when type is an Integer type" do
+      before :each do
+        @prop = Ripple::Document::Property.new(:foo, Integer)
+      end
+
+      [5.0, "5", "     5", "05", Rational(10,2)].each do |v|
+        it "should cast #{v.inspect} to 5" do
+          @prop.type_cast(v).should == 5
+        end
+      end
+
+      [0.0, "0", "     000", ""].each do |v|
+        it "should cast #{v.inspect} to 0" do
+          @prop.type_cast(v).should == 0
+        end
+      end
+
+      [true, false, [], ["something else"]].each do |v|
+        it "should raise an error casting #{v.inspect}" do
+          lambda { @prop.type_cast(v) }.should raise_error(Ripple::PropertyTypeMismatch)
+        end
+      end
+    end
+
+    describe "when type is a Float type" do
+      before :each do
+        @prop = Ripple::Document::Property.new(:foo, Float)
+      end
+
+      [0, "0", "0.0", "    0.0", ""].each do |v|
+        it "should cast #{v.inspect} to 0.0" do
+          @prop.type_cast(v).should == 0.0
+        end
+      end
+
+      [5.0, "5", "     5.0", "05", Rational(10,2)].each do |v|
+        it "should cast #{v.inspect} to 5.0" do
+          @prop.type_cast(v).should == 5.0
+        end
+      end
+
+      [true, false, :symbol, [], {}].each do |v|
+        it "should raise an error casting #{v.inspect}" do
+          lambda { @prop.type_cast(v) }.should raise_error(Ripple::PropertyTypeMismatch)
+        end
+      end
+    end
+
+    describe "when type is a Numeric type" do
+      before :each do
+        @prop = Ripple::Document::Property.new(:foo, Numeric)
+      end
+
+      [5.0, "5", "      5.0", "05"].each do |v|
+        it "should cast #{v.inspect} to 5" do
+          @prop.type_cast(v).should == 5
+        end
+      end
+
+      [5.2, "5.2542", "   6.4", "0.5327284"].each do |v|
+        it "should cast #{v.inspect} to a float" do
+          @prop.type_cast(v).should be_kind_of(Float)
+        end
+      end
+    end
+  end
+end

data/spec/ripple/ripple_spec.rb

@@ -0,0 +1,43 @@
+# 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 Ripple do
+  it "should have a client" do
+    Ripple.client.should be_kind_of(Riak::Client)
+  end
+
+  it "should have a unique client per thread" do
+    client = Ripple.client
+    th = Thread.new { Ripple.client.should_not == client }
+    th.join
+  end
+
+  it "should be configurable" do
+    Ripple.should respond_to(:config)
+  end
+
+  it "should allow setting the client manually" do
+    Ripple.should respond_to(:client=)
+    client = Riak::Client.new(:port => 9000)
+    Ripple.client = client
+    Ripple.client.should == client
+  end
+  
+  it "should reset the client when the configuration changes" do
+    c = Ripple.client
+    Ripple.config = {:port => 9000}
+    Ripple.client.should_not == c
+  end
+end

data/spec/ripple/validations_spec.rb

@@ -0,0 +1,64 @@
+# 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__)
+
+describe Ripple::Document::Validations do
+  before :all do
+    class Box; include Ripple::Document; property :shape, String end
+  end
+
+  before :each do
+    @box = Box.new
+  end
+
+  it "should add validation declarations to the class" do
+    [:validates, :validate, :validates_with, :validates_each,
+     :validates_acceptance_of, :validates_confirmation_of, :validates_exclusion_of,
+     :validates_format_of, :validates_inclusion_of, :validates_length_of,
+     :validates_numericality_of, :validates_presence_of].each do |meth|
+      Box.should respond_to(meth)
+    end
+  end
+
+  it "should add validation methods to the instance" do
+    %w{errors valid? invalid?}.each do |meth|
+      @box.should respond_to(meth)
+    end
+  end
+
+  it "should override save to run validations" do
+    @box.should_receive(:valid?).and_return(false)
+    @box.save.should be_false
+  end
+
+  it "should automatically add validations from property options" do
+    Box.property :size, Integer, :inclusion => {:in => 1..30 }
+    @box.size = 0
+    @box.should_not be_valid
+    Box.properties.delete :size
+  end
+
+  it "should run validations at the correct lifecycle state" do
+    pending "@_on_validate seems not to work?!"
+    Box.property :size, Integer
+    Box.validates_inclusion_of :size, :in => 1..30, :on => :update
+    @box.size = 0
+    @box.should be_valid
+    Box.properties.delete :size
+  end
+
+  after :all do
+    Object.send(:remove_const, :Box)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# 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.
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems' # Use the gems path only for the spec suite
+require 'ripple'
+require 'spec'
+require 'spec/autorun'
+require 'fakeweb'
+
+Dir[File.join(File.dirname(__FILE__), "support", "*.rb")].each {|f| require f }
+
+$server = MockServer.new
+at_exit { $server.stop }
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    FakeWeb.clean_registry
+  end
+end

data/spec/support/http_backend_implementation_examples.rb

@@ -0,0 +1,215 @@
+# 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.
+shared_examples_for "HTTP backend" do
+  describe "HEAD requests" do
+    before :each do
+      setup_http_mock(:head, @backend.path("/raw/","foo").to_s, :body => "")
+    end
+
+    it "should return only the headers when the request succeeds" do
+      response = @backend.head(200, "/raw/","foo")
+      response.should_not have_key(:body)
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise a FailedRequest exception when the request fails" do
+      lambda { @backend.head(301, "/raw/", "foo") }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.head(200, "/raw/") }.should raise_error(ArgumentError)
+    end
+
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.head([200, 301], "/raw/", "foo") }.should_not raise_error(Riak::FailedRequest)
+    end
+  end
+
+  describe "GET requests" do
+    before :each do
+      setup_http_mock(:get, @backend.path("/raw/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body and headers when the request succeeds" do
+      response = @backend.get(200, "/raw/","foo")
+      response[:body].should == "Success!"
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise a FailedRequest exception when the request fails" do
+      lambda { @backend.get(304, "/raw/","foo") }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.get([200, 301], "/raw/","foo") }.should_not raise_error(Riak::FailedRequest)
+    end
+    
+    it "should yield successive chunks of the response to the given block but not return the entire body" do
+      chunks = ""
+      response = @backend.get(200, "/raw/","foo") do |chunk|
+        chunks << chunk
+      end
+      chunks.should == "Success!"
+      response.should_not have_key(:body)
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.get(200, "/raw/") }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "DELETE requests" do
+    before :each do
+      setup_http_mock(:delete, @backend.path("/raw/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body and headers when the request succeeds" do
+      response = @backend.delete(200, "/raw/","foo")
+      response[:body].should == "Success!"
+      response[:headers].should be_kind_of(Hash)
+    end
+
+    it "should raise a FailedRequest exception when the request fails" do
+      lambda { @backend.delete(304, "/raw/","foo") }.should raise_error(Riak::FailedRequest)
+    end
+    
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.delete([200, 301], "/raw/","foo") }.should_not raise_error(Riak::FailedRequest)
+    end
+    
+    it "should yield successive chunks of the response to the given block but not return the entire body" do
+      chunks = ""
+      response = @backend.delete(200, "/raw/","foo") do |chunk|
+        chunks << chunk
+      end
+      chunks.should == "Success!"
+      response.should_not have_key(:body)
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.delete(200, "/raw/") }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "PUT requests" do
+    before :each do
+      setup_http_mock(:put, @backend.path("/raw/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body, headers, and code when the request succeeds" do
+      response = @backend.put(200, "/raw/","foo", "This is the body.")
+      response[:body].should == "Success!"
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise a FailedRequest exception when the request fails" do
+      lambda { @backend.put(204, "/raw/","foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+    end
+    
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.put([200, 204], "/raw/","foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+    end
+    
+    
+    it "should yield successive chunks of the response to the given block but not return the entire body" do
+      chunks = ""
+      response = @backend.put(200, "/raw/","foo", "This is the body.") do |chunk|
+        chunks << chunk
+      end
+      chunks.should == "Success!"
+      response.should_not have_key(:body)
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.put(200, "/raw/") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if no body data is given" do
+      lambda { @backend.put(200, "/raw/","foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if the body is not a string" do
+      lambda { @backend.put(200, "/raw/","foo", 123) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "POST requests" do
+    before :each do
+      setup_http_mock(:post, @backend.path("/raw/","foo").to_s, :body => "Success!")
+    end
+
+    it "should return the response body, headers, and code when the request succeeds" do
+      response = @backend.post(200, "/raw/","foo", "This is the body.")
+      response[:body].should == "Success!"
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise a FailedRequest exception when the request fails" do
+      lambda { @backend.post(204, "/raw/", "foo", "This is the body.") }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should not raise a FailedRequest if one of the expected response codes matches" do
+      lambda { @backend.post([200, 204], "/raw/", "foo", "This is the body.") }.should_not raise_error(Riak::FailedRequest)
+    end
+
+    it "should yield successive chunks of the response to the given block but not return the entire body" do
+      chunks = ""
+      response = @backend.post(200, "/raw/", "foo", "This is the body.") do |chunk|
+        chunks << chunk
+      end
+      chunks.should == "Success!"
+      response.should_not have_key(:body)
+      response[:headers].should be_kind_of(Hash)
+      response[:code].should == 200
+    end
+
+    it "should raise an error if an invalid resource path is given" do
+      lambda { @backend.post(200, "/raw/") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if no body data is given" do
+      lambda { @backend.post(200, "/raw/", "foo") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if the body is not a string" do
+      lambda { @backend.post(200, "/raw/", "foo", 123) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "Responses with no body" do
+    [204, 205, 304].each do |code|
+      [:get, :post, :put, :delete].each do |method|
+        it "should not return a body on #{method.to_s.upcase} for #{code}" do
+          setup_http_mock(method, @backend.path("/raw/","foo").to_s, :status => code)
+          response = if method == :post || method == :put
+                       @backend.send(method, code,"/raw/","foo", "This is the body")
+                     else
+                       @backend.send(method, code, "/raw/", "foo")
+                     end
+          response.should_not have_key(:body)
+        end
+      end
+    end
+  end
+end