mongomodel 0.1

data/spec/mongomodel/document/scopes_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+module MongoModel
+  describe Document do
+    before(:all) do
+      class << MongoModel::Document
+        public :with_scope, :with_exclusive_scope
+        
+        def should_find_with(hash)
+          should_receive(:_find).with(hash)
+        end
+      end
+    end
+    
+    describe "#with_scope" do
+      define_class(:Article, Document) do
+        property :title, String
+        property :author, String
+      end
+      
+      it "should deep merge finder options within block" do
+        Article.should_find_with({
+          :conditions => { :title => 'Hello World', :author => 'Editor' },
+          :limit => 10, :order => 'title ASC'
+        })
+        
+        Article.with_scope(:find => { :conditions => { :title => 'Hello World' }, :limit => 10 }) do
+          Article.find(:all, :conditions => { :author => 'Editor' }, :order => 'title ASC')
+        end
+      end
+      
+      it "should cascade multiple scopes" do
+        Article.should_find_with({
+          :conditions => { :title => 'Hello World', :author => 'Editor' },
+          :limit => 10, :order => 'title ASC', :select => :title
+        })
+        
+        Article.with_scope(:find => { :conditions => { :title => 'Hello World' }}) do
+          Article.with_scope(:find => { :select => :title, :order => 'title ASC' }) do
+            Article.find(:all, :conditions => { :author => 'Editor' }, :limit => 10)
+          end
+        end
+      end
+    end
+    
+    describe "#with_exclusive_scope" do
+      define_class(:Article, Document) do
+        property :title, String
+        property :author, String
+      end
+      
+      it "should deep merge finder options within block" do
+        Article.should_find_with({
+          :conditions => { :title => 'Hello World', :author => 'Editor' },
+          :limit => 10, :order => 'title ASC'
+        })
+        
+        Article.with_exclusive_scope(:find => { :conditions => { :title => 'Hello World' }, :limit => 10 }) do
+          Article.find(:all, :conditions => { :author => 'Editor' }, :order => 'title ASC')
+        end
+      end
+      
+      it "should not cascade non-exclusive scopes" do
+        Article.should_find_with({
+          :conditions => { :author => 'Editor' },
+          :limit => 10, :order => 'title ASC', :select => :title
+        })
+        
+        Article.with_scope(:find => { :conditions => { :title => 'Hello World' }}) do
+          Article.with_exclusive_scope(:find => { :select => :title, :order => 'title ASC' }) do
+            Article.find(:all, :conditions => { :author => 'Editor' }, :limit => 10)
+          end
+        end
+      end
+    end
+    
+    describe "#default_scope" do
+      define_class(:User, Document) do
+        property :name, String
+        property :age, Integer
+        
+        default_scope :conditions => { :age.gt => 18 }
+      end
+      
+      it "should merge with other scopes" do
+        User.should_find_with(:conditions => { :age.gt => 18 })
+        User.find(:all)
+      end
+      
+      it "should be overridable using #with_exclusive_scope" do
+        User.should_find_with({})
+        User.with_exclusive_scope({}) do
+          User.find(:all)
+        end
+      end
+    end
+    
+    describe "#named_scope" do
+      define_class(:Post, Document) do
+        property :title, String
+        property :published, Boolean
+        property :created_at, Time
+        
+        named_scope :published, :conditions => { :published => true }
+        named_scope :latest, lambda { |num| { :limit => num, :order => 'created_at DESC' } }
+        named_scope :exclusive, :exclusive => true
+      end
+      
+      define_class(:SpecialPost, :Post)
+      
+      it "should create scope methods" do
+        Post.published.options_for(:find).should == { :conditions => { :published => true} }
+        Post.latest(5).options_for(:find).should == { :limit => 5, :order => 'created_at DESC' }
+        Post.exclusive.options_for(:find).should == {}
+      end
+      
+      it "should find using scope options" do
+        Post.should_find_with(:conditions => { :published => true })
+        Post.published.find(:all)
+        
+        Post.should_find_with(:limit => 5, :order => 'created_at DESC')
+        Post.latest(5).find(:all)
+      end
+      
+      it "should find by id using scope conditions" do
+        @post1 = Post.create(:id => 'post-1', :published => true)
+        @post2 = Post.create(:id => 'post-2', :published => false)
+        
+        Post.published.find('post-1').should == @post1
+        lambda { Post.published.find('post-2') }.should raise_error(DocumentNotFound)
+      end
+      
+      it "should count using scope options" do
+        8.times { Post.create(:published => true) }
+        3.times { Post.create(:published => false) }
+        
+        Post.count.should == 11
+        Post.published.count.should == 8
+      end
+      
+      it "should be chainable" do
+        Post.should_find_with(:conditions => { :published => true }, :limit => 5, :order => 'created_at DESC')
+        Post.published.latest(5).all
+      end
+      
+      it "should inherit named scopes from parent classes" do
+        SpecialPost.published.options.should == Post.published.options
+      end
+      
+      describe "an exclusive scope" do
+        it "should override non-exclusive scopes" do
+          Post.should_find_with({})
+          Post.published.exclusive.all
+        end
+      end
+      
+      describe "#scoped" do
+        it "should create scopes on-the-fly" do
+          Post.should_find_with(:conditions => { :title => /^\d+/ })
+          Post.scoped(:conditions => { :title => /^\d+/ }).all
+        end
+      end
+    end
+  end
+  
+  module DocumentExtensions
+    describe Scope do
+      before(:each) do
+        @model = mock('Model')
+      end
+    
+      it "should be initializable with options" do
+        scope = Scope.new(@model, :find => { :conditions => { :foo => 'bar' } })
+        scope.options.should == { :find => { :conditions => { :foo => 'bar' } } }
+      end
+    
+      it "should deep merge options to create new scopes" do
+        original = Scope.new(@model, :find => { :conditions => { :foo => 'bar' } })
+        merged = original.merge(:find => { :conditions => { :baz => 123 }, :limit => 5 })
+      
+        original.options.should == { :find => { :conditions => { :foo => 'bar' } } }
+        merged.options.should == { :find => { :conditions => { :foo => 'bar', :baz => 123 }, :limit => 5 } }
+      end
+    
+      it "should deep merge options to update an existing scope" do
+        scope = Scope.new(@model, :find => { :conditions => { :foo => 'bar' } })
+        merged = scope.merge!(:find => { :conditions => { :baz => 123 }, :limit => 5 })
+      
+        merged.should == scope
+        scope.options.should == { :find => { :conditions => { :foo => 'bar', :baz => 123 }, :limit => 5 } }
+      end
+    
+      it "should have find options" do
+        scope = Scope.new(@model, :find => { :conditions => { :foo => 'bar' } })
+        scope.options_for(:find).should == { :conditions => { :foo => 'bar' } }
+      end
+    
+      it "should have default find options" do
+        scope = Scope.new(@model)
+        scope.options_for(:find).should == {}
+      end
+    end
+  end
+end

data/spec/mongomodel/document/validations/uniqueness_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    describe "validates_uniqueness_of" do
+      shared_examples_for "beating the race condition" do
+        before(:each) do
+          subject.stub!(:valid?).and_return(true, false)
+        end
+        
+        describe "save" do
+          it "should return false" do
+            subject.save.should be_false
+          end
+
+          it "should add errors to the instance" do
+            subject.save
+            subject.errors[:title].should_not be_nil
+          end
+        end
+
+        describe "save!" do
+          it "should raise a DocumentInvalid exception" do
+            lambda { subject.save! }.should raise_error(DocumentInvalid)
+          end
+
+          it "should add errors to the instance" do
+            subject.save! rescue nil
+            subject.errors[:title].should_not be_nil
+          end
+        end
+      end
+      
+      describe "basic case" do
+        define_class(:Article, Document) do
+          property :title, String
+          validates_uniqueness_of :title
+        end
+        
+        subject { Article.new(:title => 'Test') }
+        
+        it "should be valid if no document with same title exists" do
+          subject.should be_valid
+        end
+        
+        it "should not be valid if document with same title exists" do
+          Article.create!(:title => 'Test')
+          subject.should_not be_valid
+        end
+        
+        it "should be valid if document with different-cased title exists" do
+          Article.create!(:title => 'TEST')
+          subject.should be_valid
+        end
+        
+        it "should be valid if document already saved and no other document with same title exists" do
+          subject.save!
+          subject.should be_valid
+        end
+        
+        describe "beating the race condition" do
+          before(:each) { Article.create!(:title => 'Test') }
+          it_should_behave_like "beating the race condition"
+        end
+      end
+      
+      describe "with single scope" do
+        define_class(:Article, Document) do
+          property :title, String
+          property :category, String
+          validates_uniqueness_of :title, :scope => :category
+        end
+        
+        before(:each) do
+          Article.create!(:title => 'Test', :category => 'Development')
+        end
+        
+        subject { Article.new(:title => 'Test', :category => 'Testing') }
+        
+        describe "no document with same title and category exists" do
+          it { should be_valid }
+        end
+        
+        describe "document with same title and category exists" do
+          before(:each) { Article.create!(:title => 'Test', :category => 'Testing') }
+          it { should_not be_valid }
+        end
+        
+        describe "document already saved" do
+          before(:each) { subject.save! }
+          it { should be_valid }
+        end
+        
+        describe "beating the race condition" do
+          before(:each) { Article.create!(:title => 'Test', :category => 'Testing') }
+          it_should_behave_like "beating the race condition"
+        end
+      end
+      
+      describe "with array scope" do
+        define_class(:Article, Document) do
+          property :title, String
+          property :category, String
+          property :year, Integer
+          validates_uniqueness_of :title, :scope => [:category, :year]
+        end
+        
+        before(:each) do
+          Article.create!(:title => 'Test', :category => 'Development', :year => 2008)
+        end
+        
+        subject { Article.new(:title => 'Test', :category => 'Testing', :year => 2009) }
+        
+        describe "no document with same title and category exists" do
+          it { should be_valid }
+        end
+        
+        describe "document with same title and category exists" do
+          before(:each) { Article.create!(:title => 'Test', :category => 'Testing', :year => 2009) }
+          it { should_not be_valid }
+        end
+        
+        describe "document already saved" do
+          before(:each) { subject.save! }
+          it { should be_valid }
+        end
+        
+        describe "beating the race condition" do
+          before(:each) { Article.create!(:title => 'Test', :category => 'Testing', :year => 2009) }
+          it_should_behave_like "beating the race condition"
+        end
+      end
+      
+      describe "case insensitive" do
+        define_class(:Article, Document) do
+          property :title, String
+          validates_uniqueness_of :title, :case_sensitive => false
+        end
+        
+        subject { Article.new(:title => 'Test') }
+        
+        describe "no document with same title exists" do
+          it { should be_valid }
+        end
+        
+        describe "document with same title exists" do
+          before(:each) { Article.create!(:title => 'Test') }
+          it { should_not be_valid }
+        end
+        
+        describe "document with different-cased title exists" do
+          before(:each) { Article.create!(:title => 'TEST') }
+          it { should_not be_valid }
+        end
+        
+        describe "document already saved" do
+          before(:each) { subject.save! }
+          it { should be_valid }
+        end
+        
+        describe "beating the race condition" do
+          before(:each) { Article.create!(:title => 'TEST') }
+          it_should_behave_like "beating the race condition"
+        end
+      end
+      
+      describe "validation on parent class" do
+        define_class(:Article, Document) do
+          property :title, String
+          validates_uniqueness_of :title
+        end
+        define_class(:SpecialArticle, :Article)
+        
+        subject { SpecialArticle.new(:title => 'Test') }
+        
+        describe "no document with same title exists" do
+          it { should be_valid }
+        end
+        
+        describe "parent document with same title exists" do
+          before(:each) { Article.create!(:title => 'Test') }
+          it { should_not be_valid }
+        end
+        
+        describe "child document with same title exists" do
+          before(:each) { SpecialArticle.create!(:title => 'Test') }
+          it { should_not be_valid }
+        end
+      end
+      
+      describe "validation on child class" do
+        define_class(:Article, Document) do
+          property :title, String
+        end
+        define_class(:SpecialArticle, :Article) do
+          validates_uniqueness_of :title
+        end
+        
+        subject { SpecialArticle.new(:title => 'Test') }
+        
+        describe "no document with same title exists" do
+          it { should be_valid }
+        end
+        
+        describe "parent document with same title exists" do
+          before(:each) { Article.create!(:title => 'Test') }
+          it { should be_valid }
+        end
+        
+        describe "child document with same title exists" do
+          before(:each) { SpecialArticle.create!(:title => 'Test') }
+          it { should_not be_valid }
+        end
+      end
+    end
+  end
+end

data/spec/mongomodel/document/validations_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    describe "validations" do
+      define_class(:TestDocument, Document) do
+        property :title, String
+        validates_presence_of :title
+      end
+
+      context "when validations are not met" do
+        subject { TestDocument.new }
+    
+        describe "#save" do
+          it "should return false" do
+            subject.save.should be_false
+          end
+        end
+  
+        describe "#save!" do
+          before(:each) do
+            subject.errors.stub!(:full_messages).and_return(["first error", "second error"])
+          end
+    
+          it "should raise a MongoModel::DocumentInvalid exception" do
+            lambda { subject.save! }.should raise_error(MongoModel::DocumentInvalid, "Validation failed: first error, second error")
+          end
+        end
+    
+        describe "#save(false)" do
+          it "should not validate the document" do
+            subject.should_not_receive(:valid?)
+            subject.save(false)
+          end
+
+          it "should save the document" do
+            subject.should_receive(:save_without_validation).and_return(true)
+            subject.save(false)
+          end
+
+          it "should return true" do
+            subject.save(false).should be_true
+          end
+        end
+      end
+
+      describe "#create!" do
+        define_class(:User, Document) do
+          property :name, String
+          property :age, Integer
+    
+          validates_presence_of :name
+        end
+  
+        context "attributes hash" do
+          it "should pass attributes to instance" do
+            @user = User.create!(:name => 'Test', :age => 18)
+            @user.name.should == 'Test'
+            @user.age.should == 18
+          end
+  
+          it "should save! the instance" do
+            User.create!(:name => 'Test').should_not be_a_new_record
+          end
+  
+          it "should yield the instance to a given block before saving" do
+            block_called = false
+      
+            User.create!(:name => 'Test') do |u|
+              block_called = true
+        
+              u.should be_an_instance_of(User)
+              u.should be_a_new_record
+            end
+      
+            block_called.should be_true
+          end
+    
+          it "should raise an exception if the document is invalid" do
+            lambda { User.create! }.should raise_error(DocumentInvalid)
+          end
+        end
+  
+        context "array of attribute hashes" do
+          def create_users(&block)
+            User.create!([{ :name => 'Test', :age => 18 }, { :name => 'Second', :age => 21 }], &block)
+          end
+    
+          it "should return instances in array with associated attributes" do
+            @users = create_users
+            @users[0].name.should == 'Test'
+            @users[0].age.should == 18
+            @users[1].name.should == 'Second'
+            @users[1].age.should == 21
+          end
+    
+          it "should save! each instance" do
+            create_users.each { |user| user.should_not be_a_new_record }
+          end
+    
+          it "should yield each instance to a given block before saving" do
+            block_called = 0
+      
+            create_users do |u|
+              block_called += 1
+        
+              u.should be_an_instance_of(User)
+              u.should be_a_new_record
+            end
+      
+            block_called.should == 2
+          end
+    
+          it "should raise an exception if a document is invalid" do
+            lambda { User.create!([ {}, {} ]) }.should raise_error(DocumentInvalid)
+          end
+        end
+      end
+    end
+    
+    describe "validation shortcuts" do
+      define_class(:TestDocument, Document)
+      
+      describe ":unique => true" do
+        it "should add a validates_uniqueness_of validation" do
+          TestDocument.should_receive(:validates_uniqueness_of).with(:title)
+          TestDocument.property :title, String, :unique => true
+        end
+      end
+    end
+  end
+end