seomoz-ripple 1.0.0.pre

data/spec/ripple/callbacks_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe Ripple::Callbacks do
+  require 'support/models/box'
+
+  it "should add create, update, save, and destroy callback declarations" do
+    [:save, :create, :update, :destroy].each do |event|
+      Box.private_instance_methods.map(&:to_s).should include("_run_#{event}_callbacks")
+      [:before, :after, :around].each do |time|
+        Box.should respond_to("#{time}_#{event}")
+      end
+    end
+  end
+
+  it "should validate callback declarations" do
+    Box.private_instance_methods.map(&:to_s).should include("_run_validation_callbacks")
+    Box.should respond_to("before_validation")
+    Box.should respond_to("after_validation")
+  end
+
+  describe "invoking callbacks" do
+    before :each do
+      response = {:headers => {"content-type" => ["application/json"]}, :body => "{}"}
+      @client = Ripple.client
+      @backend = mock("Backend", :store_object => true)
+      @client.stub!(:backend).and_return(@backend)
+      $pinger = mock("callback verifier")
+    end
+
+    it "should call save callbacks on save" do
+      Box.before_save { $pinger.ping }
+      Box.after_save { $pinger.ping }
+      Box.around_save(lambda { $pinger.ping })
+      $pinger.should_receive(:ping).exactly(3).times
+      @box = Box.new
+      @box.save
+    end
+
+    it "propagates callbacks to embedded associated documents" do
+      Box.before_save { $pinger.ping }
+      BoxSide.before_save { $pinger.ping }
+      $pinger.should_receive(:ping).exactly(2).times
+      @box = Box.new
+      @box.sides << BoxSide.new
+      @box.save
+    end
+
+    it 'does not persist the object to riak multiple times when propagating callbacks' do
+      Box.before_save { }
+      BoxSide.before_save { }
+      @box = Box.new
+      @box.sides << BoxSide.new << BoxSide.new
+
+      @box.robject.should_receive(:store).once
+      @box.save
+    end
+
+    it 'invokes the before/after callbacks in the correct order on embedded associated documents' do
+      callbacks = []
+      BoxSide.before_save { callbacks << :before_save }
+      BoxSide.after_save  { callbacks << :after_save  }
+
+      @box = Box.new
+      @box.sides << BoxSide.new
+      @box.robject.stub(:store) do
+        callbacks << :save
+      end
+      @box.save
+
+      callbacks.should == [:before_save, :save, :after_save]
+    end
+
+    it 'does not allow around callbacks on embedded associated documents' do
+      expect {
+        BoxSide.around_save { }
+      }.to raise_error(/around_save callbacks are not supported/)
+    end
+
+    it 'does not propagate validation callbacks multiple times' do
+      Box.before_validation { $pinger.ping }
+      BoxSide.before_validation { $pinger.ping }
+      $pinger.should_receive(:ping).exactly(2).times
+      @box = Box.new
+      @box.sides << BoxSide.new
+      @box.valid?
+    end
+
+    it "should call create callbacks on save when the document is new" do
+      Box.before_create { $pinger.ping }
+      Box.after_create { $pinger.ping }
+      Box.around_create(lambda { $pinger.ping })
+      $pinger.should_receive(:ping).exactly(3).times
+      @box = Box.new
+      @box.save
+    end
+
+    it "should call update callbacks on save when the document is not new" do
+      Box.before_update { $pinger.ping }
+      Box.after_update { $pinger.ping }
+      Box.around_update(lambda { $pinger.ping })
+      $pinger.should_receive(:ping).exactly(3).times
+      @box = Box.new
+      @box.stub!(:new?).and_return(false)
+      @box.save
+    end
+
+    it "should call destroy callbacks" do
+      Box.before_destroy { $pinger.ping }
+      Box.after_destroy { $pinger.ping }
+      Box.around_destroy(lambda { $pinger.ping })
+      $pinger.should_receive(:ping).exactly(3).times
+      @box = Box.new
+      @box.destroy
+    end
+
+    it "should call save and validate callbacks in the correct order" do
+      Box.before_validation { $pinger.ping(:v) }
+      Box.before_save { $pinger.ping(:s) }
+      $pinger.should_receive(:ping).with(:v).ordered
+      $pinger.should_receive(:ping).with(:s).ordered
+      @box = Box.new
+      @box.save
+    end
+
+    describe "validation callbacks" do
+      it "should call validation callbacks" do
+        Box.before_validation { $pinger.ping }
+        Box.after_validation  { $pinger.ping }
+        $pinger.should_receive(:ping).twice
+        @box = Box.new
+        @box.valid?
+      end
+
+      it "should call validation callbacks only if the document is new" do
+        Box.before_validation(:on => :create) { $pinger.ping }
+        Box.after_validation(:on => :create) { $pinger.ping }
+        $pinger.should_receive(:ping).twice
+        @box = Box.new
+        @box.valid?
+      end
+
+      it "should not call validation callbacks only if the document is new" do
+        Box.before_validation(:on => :update) { $pinger.ping }
+        Box.after_validation(:on => :update) { $pinger.ping }
+        $pinger.should_not_receive(:ping)
+        @box = Box.new
+        @box.valid?
+      end
+
+      it "should call validation callbacks only if the document is not new" do
+        Box.before_validation(:on => :update) { $pinger.ping }
+        Box.after_validation(:on => :update) { $pinger.ping }
+        $pinger.should_receive(:ping).twice
+        @box = Box.new
+        @box.stub(:new?).and_return(false)
+        @box.valid?
+      end
+
+      it "should not call validation callbacks only if the document is not new" do
+        Box.before_validation(:on => :create) { $pinger.ping }
+        Box.after_validation(:on => :create) { $pinger.ping }
+        $pinger.should_not_receive(:ping)
+        @box = Box.new
+        @box.stub!(:new?).and_return(false)
+        @box.valid?
+      end
+    end
+
+    after :each do
+      [:save, :create, :update, :destroy, :validation].each do |type|
+        Box.reset_callbacks(type)
+        BoxSide.reset_callbacks(type)
+      end
+    end
+  end
+end

data/spec/ripple/conflict/resolver_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Ripple
+  module Conflict
+    describe Resolver do
+      it 'is registered as an on conflict hook with Riak::RObject' do
+        Riak::RObject.on_conflict_hooks.should include(described_class.to_proc)
+      end
+
+      describe 'calling the lambda returned by .to_proc' do
+        let(:sibling_1) { stub(:data => { '_type' => 'User' } ) }
+        let(:sibling_2) { stub(:data => { '_type' => 'User' } ) }
+        let(:user_siblings) { [sibling_1, sibling_2] }
+        let(:wheel_sibling) { stub(:data => { '_type' => 'Wheel' } ) }
+        let(:robject) { stub(:siblings => user_siblings) }
+        let(:resolved_robject) { stub("Resolved RObject") }
+        let(:resolved_document) { stub(:robject => resolved_robject) }
+
+        let!(:resolver) { described_class.new(robject, User) }
+
+        it 'creates a resolver for the appropriate model class, resolves the robject, and returns the resolved robject' do
+          described_class.
+            should_receive(:new).
+            with(robject, User).
+            and_return(resolver)
+
+          resolver.should_receive(:resolve)
+          resolver.stub(:document => resolved_document)
+
+          described_class.to_proc.call(robject).should be(resolved_robject)
+        end
+
+        it 'returns nil and does not attempt resolution when given an robject with siblings of different types' do
+          user_siblings << wheel_sibling
+          described_class.should_not_receive(:new)
+          described_class.to_proc.call(robject).should be_nil
+        end
+      end
+    end
+  end
+end
+

data/spec/ripple/conversion_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Ripple::Conversion do
+  require 'support/models/box'
+
+  before :each do
+    @box = Box.new { |a| a.key = 'some-key' }
+    @box.stub!(:new?).and_return(false)
+  end
+
+  it "should return the key as an array for to_key" do
+    @box.to_key.should == ['some-key']
+  end
+
+  it "should be able to be converted to a param" do
+    @box.to_param.should == 'some-key'
+  end
+
+  it "should be able to be converted to a model" do
+    @box.to_model.should == @box
+  end
+end

data/spec/ripple/core_ext_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Time do
+  before { @date_format = Ripple.date_format }
+  after  { Ripple.date_format = @date_format }
+
+  it "serializes to JSON in UTC, ISO 8601 format by default" do
+    Time.utc(2010,3,16,12).as_json.should == "2010-03-16T12:00:00Z"
+  end
+
+  it "serializes to JSON in UTC, RFC822 format when specified" do
+    Ripple.date_format = :rfc822
+    Time.utc(2010,3,16,12).as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+  end
+end
+
+describe Date do
+  before { @date_format = Ripple.date_format }
+  after  { Ripple.date_format = @date_format }
+
+  it "serializes to JSON ISO 8601 format by default" do
+    Date.civil(2010,3,16).as_json.should == "2010-03-16"
+  end
+
+  it "serializes to JSON in UTC, RFC822 format when specified" do
+    Ripple.date_format = :rfc822
+    Date.civil(2010,3,16).as_json.should == "16 Mar 2010"
+  end
+end
+
+describe DateTime do
+  before { @date_format = Ripple.date_format }
+  after  { Ripple.date_format = @date_format }
+
+  before :each do
+    Time.zone = :utc
+  end
+
+  it "serializes to JSON in UTC, ISO 8601 format by default" do
+    DateTime.civil(2010,3,16,12).as_json.should == "2010-03-16T12:00:00+00:00"
+  end
+
+  it "serializes to JSON in UTC, RFC822 format when specified" do
+    Ripple.date_format = :rfc822
+    DateTime.civil(2010,3,16,12).as_json.should == "Tue, 16 Mar 2010 12:00:00 +0000"
+  end
+end
+
+describe ActiveSupport::TimeWithZone do
+  before { @date_format = Ripple.date_format }
+  after  { Ripple.date_format = @date_format }
+
+  it "serializes to JSON in UTC, ISO 8601 format by default" do
+    time = Time.utc(2010,3,16,12)
+    zone = ActiveSupport::TimeZone['Alaska']
+    ActiveSupport::TimeWithZone.new(time, zone).as_json.should == "2010-03-16T12:00:00Z"
+  end
+
+  it "serializes to JSON in UTC, RFC822 format when specified" do
+    Ripple.date_format = :rfc822
+    time = Time.utc(2010,3,16,12)
+    zone = ActiveSupport::TimeZone['Alaska']
+    ActiveSupport::TimeWithZone.new(time, zone).as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+  end
+end
+
+describe String do
+  it "can parse RFC 822 and ISO 8601 times" do
+    'Tue, 16 Mar 2010 12:00:00 -0000'.to_time.should == Time.utc(2010,3,16,12)
+    '2010-03-16T12:00:00Z'.to_time.should == Time.utc(2010,3,16,12)
+  end
+
+  it "can parse RFC 822 and ISO 8601 dates" do
+    '16 Mar 2010'.to_date.should == Date.civil(2010,3,16)
+    '2010-3-16'.to_date.should == Date.civil(2010,3,16)
+  end
+
+  it "can parse RFC 822 and ISO 8601 datetimes" do
+    'Tue, 16 Mar 2010 12:00:00 +0000'.to_datetime.should == DateTime.civil(2010,3,16,12)
+    '2010-03-16T12:00:00+00:00'.to_datetime.should == DateTime.civil(2010,3,16,12)
+  end
+end
+
+describe "Boolean" do
+  it "should be available to properties on documents" do
+    lambda {
+      class BooleanTest
+        include Ripple::Document
+        property :foo, Boolean
+      end
+    }.should_not raise_error(NameError)
+  end
+end
+
+describe Set do
+  describe "#as_json" do
+    it 'returns an array of the #as_json result of each element' do
+      set = Set.new([stub(:as_json => 's1'), stub(:as_json => 's2')])
+      set.as_json.should =~ ['s1', 's2']
+    end
+  end
+end
+

data/spec/ripple/document/link_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Ripple
+  module Document
+    describe self do
+      describe "#to_link" do
+        let(:tag)      { 'invoices' }
+        let(:document) { Invoice.new }
+        let(:to_link)  { document.to_link(tag) }
+
+        it "returns a #{described_class}::Link" do
+          to_link.should be_a(Link)
+        end
+
+        it "sets the document to this document" do
+          to_link.send(:document).should equal(document)
+        end
+
+        it "sets the tag to the given tag" do
+          to_link.tag.should == tag
+        end
+      end
+    end
+
+    describe Link do
+      let(:key)      { 'the-invoice-key' }
+      let(:tag)      { 'invoices' }
+      let(:document) { Invoice.new { |i| i.key = key } }
+      let(:link)     { described_class.new(document, tag) }
+
+      it 'does not fetch the key immediately' do
+        document.should_not_receive(:key)
+        link
+      end
+
+      describe '#key' do
+        it "returns the document's key" do
+          link.key.should == key
+        end
+      end
+
+      describe '#bucket' do
+        it "returns the bucket name from the document class" do
+          link.bucket.should == Invoice.bucket_name
+        end
+      end
+
+      describe '#tag' do
+        it 'returns the tag passed to the constructor' do
+          link.tag.should == tag
+        end
+      end
+
+      describe "#hash" do
+        it 'does not use the key' do
+          document.should_not_receive(:key)
+          link.hash
+        end
+
+        it "uses the document's #hash" do
+          document.should_receive(:hash).and_return(1234)
+          link.hash.should == 1234
+        end
+      end
+    end
+  end
+end

data/spec/ripple/document_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Ripple::Document do
+  require 'support/models/page'
+
+  it "should add bucket access methods to classes when included" do
+    (class << Page; self; end).included_modules.should include(Ripple::Document::BucketAccess)
+    Page.should respond_to(:bucket_name)
+    Page.should respond_to(:bucket)
+    Page.should respond_to(:bucket_name=)
+  end
+
+  it "should not be embeddable" do
+    Page.should_not be_embeddable
+  end
+
+  describe "equivalence" do
+    before do
+      class Homepage < Page; end
+      class ErrorPage; include Ripple::Document; self.bucket_name = "pages"; end
+      @doc = Page.new
+      @doc2 = Page.new
+      @sub = Homepage.new
+      @error = ErrorPage.new
+      [@doc,@doc2,@sub,@error].each {|d| d.key = "root"; d.stub!(:new?).and_return(false) }
+    end
+
+    it "should be == and eql? if the same object, and have the same hash key" do
+      @doc.should == @doc
+      @doc.should eql(@doc)
+      @doc.hash.should == @doc.hash
+    end
+
+    it "should be == and eql? and have the same hash key if instance of same class and key" do
+      @doc.should == @doc2
+      @doc2.should == @doc
+      @doc.should eql(@doc2)
+      @doc2.should eql(@doc)
+      @doc.hash.should == @doc2.hash
+    end
+
+    it "should be == but not eql? and have different hash keys if they have the same key but one is a subclass of the other" do
+      @doc.should == @sub
+      @sub.should == @doc
+
+      @doc.should_not eql(@sub)
+      @sub.should_not eql(@doc)
+
+      @doc.hash.should_not == @sub.hash
+    end
+
+    it "should be == but not eql? and have different hash keys if of the same bucket and key" do
+      @doc.should == @error
+      @error.should == @doc
+
+      @doc.should_not eql(@error)
+      @error.should_not eql(@doc)
+
+      @doc.hash.should_not == @error.hash
+      @error.hash.should_not == @doc.hash
+    end
+
+    it "should not be == or eql? or have the same hash key if new record" do
+      @doc2.stub!(:new?).and_return(true)
+      @doc.should_not == @doc2
+      @doc2.should_not == @doc
+
+      @doc.should_not eql(@doc2)
+      @doc2.should_not eql(@doc)
+
+      @doc.hash.should_not == @doc2.hash
+    end
+  end
+
+  describe "ActiveModel compatibility" do
+    include ActiveModel::Lint::Tests
+
+    before :each do
+      @model = Page.new
+    end
+
+    def assert(value, message="")
+      value.should be
+    end
+
+    def assert_kind_of(klass, value)
+      value.should be_kind_of(klass)
+    end
+
+    ActiveModel::Lint::Tests.instance_methods.grep(/^test/).each do |m|
+      it "#{m}" do
+        send(m)
+      end
+    end
+  end
+end