seomoz-ripple 1.0.0.pre

data/spec/ripple/embedded_document/finders_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Ripple::EmbeddedDocument::Finders do
+  require 'support/models/address'
+  require 'support/models/favorite'
+
+  before :each do
+    @address = Address.new
+  end
+
+  it "should instantiate a document" do
+    Address.stub!(:new).and_return(@address)
+    Address.instantiate('_type' => 'Address').should == @address
+  end
+  
+  it "should instantiate a class of _type if present in attrs" do
+    Favorite.instantiate('_type' => 'Address').class.should == Address
+  end
+  
+  it "should use self if being called from a class including Ripple::EmbeddedDocument and _type is not present" do
+    Address.instantiate({}).class.should == Address
+  end
+
+  it 'initializes the document with no changes' do
+    a = Address.instantiate('_type' => 'Address', 'street' => 'Pine St')
+    a.should_not be_changed
+    a.changes.should be_empty
+  end
+end

data/spec/ripple/embedded_document/persistence_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Ripple::EmbeddedDocument::Persistence do
+  require 'support/models/user'
+  require 'support/models/address'
+  
+  before :each do
+    @root = User.new
+    @addr = Address.new(:street => "196 Broadway")
+    @addr._parent_document = @root
+  end
+
+  it "should delegate new? to the root document" do
+    @root.should_receive(:new?).and_return(true)
+    @addr.should be_new
+  end
+
+  it "should delegate save to the root document" do
+    @root.should_receive(:save).and_return(true)
+    @addr.save.should be_true
+  end
+  
+  it "should delegate save! to the root document" do
+    @root.should_receive(:save).and_return(true)
+    @addr.save!.should be_true
+  end
+  
+  it "should raise NoRootDocument when calling save without a root document" do
+    @addr._parent_document = nil
+    lambda { @addr.save }.should raise_error(Ripple::NoRootDocument)
+  end
+  
+  it "should raise NoRootDocument when calling save! without a root document" do
+    @addr._parent_document = nil
+    lambda { @addr.save! }.should raise_error(Ripple::NoRootDocument)
+  end
+
+  it "should have a root document" do
+    @addr._root_document.should == @root
+  end
+  
+  it "should have a parent document" do
+     @addr._parent_document.should == @root
+  end
+  
+  it "should respond to new_record?" do
+    @addr.should respond_to(:new_record?)
+    @addr.should be_a_new_record
+  end
+  
+  it "should respond to persisted" do
+    @addr.should respond_to(:persisted?)
+    @addr.should_not be_persisted
+  end
+  
+  it "should properly create embedded attributes for persistence" do
+    @addr = Address.new
+    @root.addresses << @addr
+    @root.attributes_for_persistence.should == {'_type' => 'User', 'addresses' => [{'_type' => 'Address', 'street' => nil}]}
+  end
+
+  it "includes undefined properties in the attributes for persistence" do
+    addr = Address.new
+    addr['some_undefined_prop'] = 17
+    @root.addresses << addr
+    @root.attributes_for_persistence['addresses'].first.should include('some_undefined_prop' => 17)
+  end
+
+  it "should modify its attributes and save" do
+    @addr.should_receive(:save).and_return(true)
+    @addr.update_attributes(:street => "4 Folsom Ave")
+    @addr.street.should == "4 Folsom Ave"
+  end
+
+  it "should update a single attribute and save without validations" do
+    @addr.should_receive(:save).with(:validate => false).and_return(true)
+    @addr.update_attribute(:street, "4 Folsom Ave")
+    @addr.street.should == "4 Folsom Ave"
+  end
+end

data/spec/ripple/embedded_document_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Ripple::EmbeddedDocument do
+  require 'support/models/address'
+  require 'support/models/user'
+
+  it "should have a model name when included" do
+    Address.should respond_to(:model_name)
+    Address.model_name.should be_kind_of(ActiveModel::Name)
+  end
+
+  it "should be embeddable" do
+    Address.should be_embeddable
+  end
+
+  describe "equality" do
+    let(:user_1) { User.new {|u| u.key = "u1"} }
+    let(:user_2) { User.new {|u| u.key = "u2"} }
+    let(:street_1) { '123 Somewhere St' }
+    let(:street_2) { '123 Somewhere Ave' }
+    let(:address_1) { Address.new(:street => street_1) }
+    let(:address_2) { Address.new(:street => street_1) }
+
+    before(:each) do
+      address_1._parent_document = user_1
+      address_2._parent_document = user_1
+    end
+
+    def should_be_equal
+      (address_1 == address_2).should be_true
+      address_1.eql?(address_2).should be_true
+
+      (address_2 == address_1).should be_true
+      address_2.eql?(address_1).should be_true
+
+      address_1.hash.should == address_2.hash
+    end
+
+    def should_not_be_equal(other_address = address_2)
+      (address_1 == other_address).should be_false
+      address_1.eql?(other_address).should be_false
+
+      (other_address == address_1).should be_false
+      address_1.eql?(other_address).should be_false
+
+      address_1.hash.should_not == other_address.hash
+    end
+
+    specify "two document are equal when they have the same classes, parents and attributes" do
+      should_be_equal
+    end
+
+    specify "two documents are not equal when the parents are different (even if the attributes and classes are the same)" do
+      address_2._parent_document = user_2
+      should_not_be_equal
+    end
+
+    specify "two documents are not equal when the attributes are different (even if the parents and classes are the same)" do
+      address_2.street = street_2
+      should_not_be_equal
+    end
+
+    specify "two documents are not equal when the classes are different (even if the parents and attributes are the same)" do
+      special_address = SpecialAddress.new(address_1.attributes)
+      special_address._parent_document = address_1._parent_document
+
+      should_not_be_equal(special_address)
+    end
+
+    specify "two documents are not equal when their embedded documents are not equal (even if they are identical otherwise)" do
+      address_1.notes << Note.new(:text => 'Bob lives here')
+      address_2.notes << Note.new(:text => 'Jill lives here')
+
+      should_not_be_equal
+    end
+
+    specify "two documents can be equal when their embedded doc objects are different instances but are equal" do
+      address_1.notes << Note.new(:text => 'Bob lives here')
+      address_2.notes << Note.new(:text => 'Bob lives here')
+
+      should_be_equal
+    end
+  end
+end

data/spec/ripple/finders_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Ripple::Document::Finders do
+  require 'support/models/box'
+  require 'support/models/cardboard_box'
+  
+  before :each do
+    @backend = mock("Backend")
+    @client = Ripple.client
+    @client.stub!(:backend).and_return(@backend)
+    @bucket = Ripple.client.bucket("boxes")
+    @plain = Riak::RObject.new(@bucket, "square"){|o| o.content_type = "application/json"; o.raw_data = '{"shape":"square"}'}
+    @cb = Riak::RObject.new(@bucket, "rectangle"){|o| o.content_type = "application/json"; o.raw_data = '{"shape":"rectangle"}'}
+  end
+
+  it "should return nil if no keys are passed to find" do
+    Box.find().should be_nil
+  end
+
+  it "should return nil if no valid keys are passed to find" do
+    Box.find(nil).should be_nil
+    Box.find("").should be_nil
+  end
+  
+  it "should raise Ripple::DocumentNotFound if an empty array is passed to find!" do
+    lambda { Box.find!() }.should raise_error(Ripple::DocumentNotFound, "Couldn't find document without a key")
+  end
+
+  describe "finding single documents" do
+    before do
+      @bucket.stub!(:get).with("square", {}).and_return(@plain)
+    end
+    
+    it "should find a single document by key and assign its attributes" do
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      box = Box.find("square")
+      box.should be_kind_of(Box)
+      box.shape.should == "square"
+      box.key.should == "square"
+      box.instance_variable_get(:@robject).should_not be_nil
+      box.should_not be_new_record
+    end
+
+    it "should find the first document using the first key with the bucket's keys" do
+      box  = Box.new
+      keys = ['some_boxes_key']
+      Box.stub!(:find).and_return(box)
+      @bucket.stub!(:keys).and_return(keys)
+      @bucket.should_receive(:keys)
+      keys.should_receive(:first)
+      Box.first.should == box
+    end
+
+    it "should use find! when using first!" do
+      box = Box.new
+      Box.stub!(:find!).and_return(box)
+      @bucket.stub!(:keys).and_return(['key'])
+      Box.first!.should == box
+    end
+
+    it "should not raise an exception when finding an existing document with find!" do
+      lambda { Box.find!("square") }.should_not raise_error(Ripple::DocumentNotFound)
+    end
+
+    it "should put properties we don't know about into the attributes" do
+      @plain.raw_data = '{"non_existent_property":"some_value"}'
+      box = Box.find("square")
+      box[:non_existent_property].should == "some_value"
+      box.should_not respond_to(:non_existent_property)
+    end
+
+    it "should return the document when calling find!" do
+      box = Box.find!("square")
+      box.should be_kind_of(Box)
+    end
+
+    it "should return nil when no object exists at that key" do
+      @bucket.should_receive(:get).with("square", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      box = Box.find("square")
+      box.should be_nil
+    end
+
+    it "should raise DocumentNotFound when using find! if no object exists at that key" do
+      @bucket.should_receive(:get).with("square", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      lambda { Box.find!("square") }.should raise_error(Ripple::DocumentNotFound, "Couldn't find document with key: square")
+    end
+
+    it "should re-raise the failed request exception if not a 404" do
+      @bucket.should_receive(:get).with("square", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 500, {}, "500 internal server error"))
+      lambda { Box.find("square") }.should raise_error(Riak::FailedRequest)
+    end
+
+    it "should handle a key with a nil value" do
+      @plain.raw_data = nil
+      @plain.data = nil
+      box = Box.find("square")
+      box.should be_kind_of(Box)
+      box.key.should == "square"
+    end
+
+    it 'initializes the document with no changed attributes' do
+      box = Box.find("square")
+      box.should_not be_changed
+      box.changes.should be_empty
+    end
+  end
+
+  describe "finding multiple documents when given a splat of keys" do
+    it "should find multiple documents by the keys" do
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_return(@cb)
+      boxes = Box.find("square", "rectangle")
+      boxes.should have(2).items
+      boxes.first.shape.should == "square"
+      boxes.last.shape.should == "rectangle"
+    end
+
+    describe "when using find with missing keys" do
+      before :each do
+        @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+        @bucket.should_receive(:get).with("rectangle", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      end
+
+      it "should return nil for documents that no longer exist" do
+        boxes = Box.find("square", "rectangle")
+        boxes.should have(2).items
+        boxes.first.shape.should == "square"
+        boxes.last.should be_nil
+      end
+
+      it "should raise Ripple::DocumentNotFound when calling find! if some of the documents do not exist" do
+        lambda { Box.find!("square", "rectangle") }.should raise_error(Ripple::DocumentNotFound, "Couldn't find documents with keys: rectangle")
+      end
+    end
+  end
+
+  describe "finding multiple documents when given an array" do
+    it "should find multiple documents by the keys" do
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_return(@cb)
+      boxes = Box.find(["square", "rectangle"])
+      boxes.should have(2).items
+      boxes.first.shape.should == "square"
+      boxes.last.shape.should == "rectangle"
+    end
+
+    it "should return an array of docs when given an array of one key" do
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      boxes = Box.find(["square"])
+      boxes.should have(1).items
+      boxes.first.shape.should == "square"
+    end
+
+    it "should return an empty array when given an empty array" do
+      Box.find([ ]).should == []
+    end
+
+    describe "when using find with missing keys" do
+      before :each do
+        @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+        @bucket.should_receive(:get).with("rectangle", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      end
+
+      it "should return nil for documents that no longer exist" do
+        boxes = Box.find(["square", "rectangle"])
+        boxes.should have(2).items
+        boxes.first.shape.should == "square"
+        boxes.last.should be_nil
+      end
+    end
+  end
+
+  describe "listings all documents in the bucket" do
+    it "should load all objects in the bucket" do
+      @bucket.should_receive(:keys).and_return(["square", "rectangle"])
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_return(@cb)
+      boxes = Box.list
+      boxes.should have(2).items
+      boxes.first.shape.should == "square"
+      boxes.last.shape.should == "rectangle"
+    end
+
+    it "should exclude objects that are not found" do
+      @bucket.should_receive(:keys).and_return(["square", "rectangle"])
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      boxes = Box.list
+      boxes.should have(1).item
+      boxes.first.shape.should == "square"
+    end
+
+    it "should yield found objects to the passed block, excluding missing objects, and return an empty array" do
+      @bucket.should_receive(:keys).and_yield(["square"]).and_yield(["rectangle"])
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_raise(Riak::HTTPFailedRequest.new(:get, 200, 404, {}, "404 not found"))
+      @block = mock()
+      @block.should_receive(:ping).once
+      Box.list do |box|
+        @block.ping
+        ["square", "rectangle"].should include(box.shape)
+      end.should == []
+    end
+  end
+
+  describe "single-bucket inheritance" do
+    it "should instantiate as the proper type if defined in the document" do
+      @cb.raw_data = '{"shape":"rectangle", "_type":"CardboardBox"}'
+      @bucket.should_receive(:get).with("square", {}).and_return(@plain)
+      @bucket.should_receive(:get).with("rectangle", {}).and_return(@cb)
+      boxes = Box.find("square", "rectangle")
+      boxes.should have(2).items
+      boxes.first.class.should == Box
+      boxes.last.should be_kind_of(CardboardBox)
+    end
+  end
+end

data/spec/ripple/inspection_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Ripple::Inspection do
+  require 'support/models/box'
+  require 'support/models/address'
+
+  shared_examples_for 'an inspected document' do |method|
+
+    it "should include the class name in the inspect string" do
+      @box.send(method).should be_starts_with("<Box")
+    end
+
+    it "should include the key in the #{method} string for documents" do
+      @box.key = "square"
+      @box.send(method).should be_starts_with("<Box:square")
+    end
+
+    it "should indicate a new document when no key is specified" do
+      @box.send(method).should be_starts_with("<Box:[new]")
+    end
+
+    it "should not display a key for embedded documents" do
+      @address.send(method).should_not include("[new]")
+    end
+
+  end
+
+  before :each do
+    @box = Box.new
+    @address = Address.new
+  end
+
+  describe '#inspect' do
+
+    it_should_behave_like 'an inspected document', :inspect
+
+    it "should enumerate the document's properties and their values" do
+      @box.shape = "square"
+      @box.inspect.should include("shape=\"square\"")
+      @box.inspect.should include("created_at=")
+      @box.inspect.should include("updated_at=")
+    end
+
+  end
+
+  describe '#to_s' do
+
+    it_should_behave_like 'an inspected document', :to_s
+
+  end
+end