mongomodel 0.1

data/spec/mongomodel/document/callbacks_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    describe "callbacks" do
+      define_class(:CallbackTestDocument, Document) do
+        include MongoModel::CallbackHelpers
+      end
+      
+      let(:doc) { CallbackTestDocument.create! }
+      
+      it "should run each type of callback when initializing" do
+        instance = CallbackTestDocument.new
+        instance.should run_callbacks(:after_initialize)
+      end
+  
+      it "should run each type of callback on find" do
+        instance = CallbackTestDocument.find(doc.id)
+        instance.should run_callbacks(:after_initialize, :after_find)
+      end
+  
+      it "should run each type of callback when validating a new document" do
+        instance = CallbackTestDocument.new
+        instance.valid?
+        instance.should run_callbacks(:after_initialize, :before_validation, :after_validation)
+      end
+  
+      it "should run each type of callback when validating an existing document" do
+        instance = CallbackTestDocument.find(doc.id)
+        instance.valid?
+        instance.should run_callbacks(:after_initialize, :after_find, :before_validation, :after_validation)
+      end
+  
+      it "should run each type of callback when creating a document" do
+        instance = CallbackTestDocument.create!
+        instance.should run_callbacks(:after_initialize, :before_validation, :after_validation, :before_save, :before_create, :after_create, :after_save)
+      end
+  
+      it "should run each type of callback when saving an existing document" do
+        instance = CallbackTestDocument.find(doc.id)
+        instance.save
+        instance.should run_callbacks(:after_initialize, :after_find, :before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save)
+      end
+  
+      it "should run each type of callback when destroying a document" do
+        instance = CallbackTestDocument.find(doc.id)
+        instance.destroy
+        instance.should run_callbacks(:after_initialize, :after_find, :before_destroy, :after_destroy)
+      end
+  
+      it "should not run destroy callbacks when deleting a document" do
+        instance = CallbackTestDocument.find(doc.id)
+        instance.delete
+        instance.should run_callbacks(:after_initialize, :after_find)
+      end
+    end
+      
+    [ :before_save, :before_create ].each do |callback|
+      context "#{callback} callback return false" do
+        define_class(:CallbackTestDocument, Document) do
+          send(callback) { false }
+        end
+      
+        subject { CallbackTestDocument.new }
+      
+        describe "#save" do
+          it "should return false" do
+            subject.save.should be_false
+          end
+        end
+      
+        describe "#save!" do
+          it "should raise a MongoModel::DocumentNotSaved exception" do
+            lambda { subject.save! }.should raise_error(MongoModel::DocumentNotSaved)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongomodel/document/dynamic_finders_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    describe "dynamic finders" do
+      define_class(:Person, Document) do
+        property :name, String
+        property :age, Integer
+      end
+      
+      subject { Person }
+      
+      before(:each) do
+        @john = Person.create!(:name => 'John', :age => 42, :id => '1')
+        @young_john = Person.create!(:name => 'John', :age => 12, :id => '2')
+        @tom1 = Person.create!(:name => 'Tom', :age => 23, :id => '3')
+        @tom2 = Person.create!(:name => 'Tom', :age => 23, :id => '4')
+        @mary = Person.create!(:name => 'Mary', :age => 33, :id => '5')
+      end
+      
+      shared_examples_for "a dynamic finder" do
+        it { should respond_to(valid_finder) }
+        it { should_not respond_to(invalid_finder) }
+        
+        it "should raise NoMethodError calling an invalid finder" do
+          lambda { subject.send(invalid_finder, "Foo") }.should raise_error(NoMethodError)
+        end
+        
+        def self.should_find(*args, &block)
+          it "should return correct results when called with #{args.inspect}" do
+            expected = instance_eval(&block)
+            subject.send(valid_finder, *args).should == expected
+          end
+        end
+        
+        def self.should_raise(*args, &block)
+          it "should raise DocumentNotFound exception if results not found" do
+            message = instance_eval(&block)
+            lambda { subject.send(valid_finder, *args) }.should raise_error(DocumentNotFound, message)
+          end
+        end
+        
+        def self.should_initialize(*args, &block)
+          it "should initialize new instance" do
+            result = subject.send(valid_finder, *args)
+            result.should be_a_new_record
+            result.should be_an_instance_of(Person)
+            yield(result).should be_true
+          end
+        end
+        
+        def self.should_create(*args, &block)
+          it "should create new instance" do
+            result = subject.send(valid_finder, *args)
+            result.should_not be_a_new_record
+            result.should be_an_instance_of(Person)
+            yield(result).should be_true
+          end
+        end
+      end
+      
+      describe "find first by single property" do
+        let(:valid_finder) { :find_by_name }
+        let(:invalid_finder) { :find_by_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { @john }
+        should_find("John", :conditions => { :age.lt => 20 }) { @young_john }
+        should_find("Jane") { nil }
+      end
+      
+      describe "find first by single property (bang method)" do
+        let(:valid_finder) { :find_by_name! }
+        let(:invalid_finder) { :find_by_something_else! }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { @john }
+        should_raise("Jane") { 'Couldn\'t find Person with {:name=>"Jane"}' }
+      end
+      
+      describe "find last by single property" do
+        let(:valid_finder) { :find_last_by_name }
+        let(:invalid_finder) { :find_last_by_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { @young_john }
+        should_find("Jane") { nil }
+      end
+      
+      describe "find all by single property" do
+        let(:valid_finder) { :find_all_by_name }
+        let(:invalid_finder) { :find_all_by_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { [@john, @young_john] }
+      end
+      
+      describe "find first by multiple properties" do
+        let(:valid_finder) { :find_by_name_and_age }
+        let(:invalid_finder) { :find_by_age_and_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("Tom", 23) { @tom1 }
+        should_find("Tom", 5) { nil }
+      end
+      
+      describe "find first by multiple properties (bang method)" do
+        let(:valid_finder) { :find_by_name_and_age! }
+        let(:invalid_finder) { :find_by_age_and_something_else! }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("Tom", 23) { @tom1 }
+        should_raise("Tom", 5) { "Couldn\'t find Person with #{{:name=>"Tom", :age=>5}.inspect}" }
+      end
+      
+      describe "find all by multiple properties" do
+        let(:valid_finder) { :find_all_by_name_and_age }
+        let(:invalid_finder) { :find_all_by_age_and_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("Tom", 23) { [@tom1, @tom2] }
+        should_find("Tom", 5) { [] }
+      end
+      
+      describe "find last by multiple properties" do
+        let(:valid_finder) { :find_last_by_name_and_age }
+        let(:invalid_finder) { :find_last_by_age_and_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("Tom", 23) { @tom2 }
+        should_find("Tom", 5) { nil }
+      end
+      
+      describe "find or initialize by single property" do
+        let(:valid_finder) { :find_or_initialize_by_name }
+        let(:invalid_finder) { :find_or_initialize_by_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { @john }
+        should_initialize("Jane") { |p| p.name == "Jane" }
+      end
+      
+      describe "find or initialize by multiple properties" do
+        let(:valid_finder) { :find_or_initialize_by_name_and_age }
+        let(:invalid_finder) { :find_or_initialize_by_name_and_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John", 42) { @john }
+        should_initialize("John", 1) { |p| p.name == "John" && p.age == 1 }
+      end
+      
+      describe "find or create by single property" do
+        let(:valid_finder) { :find_or_create_by_name }
+        let(:invalid_finder) { :find_or_create_by_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John") { @john }
+        should_create("Jane") { |p| p.name == "Jane" }
+      end
+      
+      describe "find or create by multiple properties" do
+        let(:valid_finder) { :find_or_create_by_name_and_age }
+        let(:invalid_finder) { :find_or_create_by_name_and_something_else }
+        
+        it_should_behave_like "a dynamic finder"
+        
+        should_find("John", 42) { @john }
+        should_create("John", 1) { |p| p.name == "John" && p.age == 1 }
+      end
+    end
+  end
+end

data/spec/mongomodel/document/finders_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+module MongoModel
+  describe Document do
+    define_class(:User, Document) do
+      property :name, String
+      property :age, Integer
+    end
+    
+    define_class(:NonUser, Document)
+    
+    describe "#find" do
+      before(:each) do
+        User.collection.save({ '_id' => '1', 'name' => 'Fred', :age => 45 })
+        User.collection.save({ '_id' => '2', 'name' => 'Alistair', :age => 18 })
+        User.collection.save({ '_id' => '3', 'name' => 'Barney', :age => 10 })
+      end
+      
+      describe "by id" do
+        context "document exists" do
+          subject { User.find('2') }
+          
+          it "should return a User" do
+            subject.should be_a(User)
+          end
+          
+          it "should load the document attributes" do
+            subject.id.should == '2'
+            subject.name.should == 'Alistair'
+          end
+          
+          it { should_not be_a_new_record }
+          
+          it "should stringify ids" do
+            User.find(2).id.should == '2'
+          end
+        end
+        
+        context "document does not exist" do
+          it "should raise a DocumentNotFound exception" do
+            lambda {
+              User.find('4')
+            }.should raise_error(MongoModel::DocumentNotFound)
+          end
+        end
+        
+        context "no id specified" do
+          it "should raise an ArgumentError" do
+            lambda { 
+              User.find
+            }.should raise_error(ArgumentError)
+          end
+        end
+      end
+      
+      describe "by multiple ids" do
+        context "all documents exist" do
+          subject { User.find('1', '2') }
+          
+          it "should return an array of Users" do
+            subject[0].should be_a(User)
+            subject[1].should be_a(User)
+          end
+          
+          it "should load document attributes" do
+            subject[0].name.should == 'Fred'
+            subject[1].name.should == 'Alistair'
+          end
+          
+          it "should load documents in correct order" do
+            result = User.find('2', '1')
+            result[0].id.should == '2'
+            result[1].id.should == '1'
+          end
+        end
+        
+        context "some documents missing" do
+          it "should raise a DocumentNotFound exception" do
+            lambda {
+              User.find('1', '2', '4')
+            }.should raise_error(MongoModel::DocumentNotFound)
+          end
+        end
+      end
+      
+      describe "first" do
+        context "documents exist" do
+          subject { User.find(:first) }
+          
+          it "should return the first document" do
+            subject.id.should == '1'
+            subject.name.should == 'Fred'
+          end
+          
+          it "should be aliased as #first" do
+            User.first.should == subject
+          end
+          
+          context "with order" do
+            it "should find first document by order" do
+              User.find(:first, :order => :name.asc).name.should == 'Alistair'
+            end
+          end
+        end
+        
+        context "no documents" do
+          before(:each) { User.collection.remove }
+          
+          it "should return nil" do
+            User.find(:first).should be_nil
+          end
+        end
+      end
+      
+      describe "last" do
+        context "documents exist" do
+          subject { User.find(:last) }
+          
+          it "should return the last document (by id)" do
+            subject.id.should == '3'
+            subject.name.should == 'Barney'
+          end
+          
+          it "should be aliased as #last" do
+            User.last.should == subject
+          end
+          
+          context "with order" do
+            it "should find last document by order" do
+              User.find(:last, :order => :name.asc).name.should == 'Fred'
+            end
+          end
+        end
+        
+        context "no documents" do
+          before(:each) { User.collection.remove }
+          
+          it "should return nil" do
+            User.find(:last).should be_nil
+          end
+        end
+      end
+      
+      describe "all" do
+        subject { User.find(:all, :order => 'id ASC') }
+        
+        it "should return all documents as User instances" do
+          subject.should have(3).users
+          subject.each { |d| d.should be_a(User) }
+        end
+        
+        it "should load attributes for each document" do
+          subject[0].name.should == 'Fred'
+          subject[1].name.should == 'Alistair'
+          subject[2].name.should == 'Barney'
+        end
+        
+        it "should be aliased as #all" do
+          User.all.should == subject
+        end
+        
+        context "with exact-match conditions" do
+          subject { User.find(:all, :conditions => { :name => 'Alistair' }) }
+          
+          it "should only return documents matching conditions" do
+            subject.should have(1).user
+            subject[0].name.should == 'Alistair'
+          end
+        end
+        
+        context "with inequality conditions" do
+          subject { User.find(:all, :conditions => { :age.lt => 21 }) }
+          
+          it "should only return documents matching conditions" do
+            subject.should have(2).users
+            subject[0].name.should == 'Alistair'
+            subject[1].name.should == 'Barney'
+          end
+        end
+      end
+    end
+    
+    describe "#count" do
+      before(:each) do
+        5.times { User.create(:age => 18) }
+        7.times { User.create(:age => 42) }
+        3.times { NonUser.create }
+      end
+      
+      context "without arguments" do
+        it "should return the count for that particular model" do
+          User.count.should == 12
+          NonUser.count.should == 3
+        end
+      end
+      
+      context "with conditions" do
+        it "should return the count for the model that match the conditions" do
+          User.count(:age => 18).should == 5
+          User.count(:age.gte => 18).should == 12
+        end
+      end
+    end
+    
+    describe "#exists?" do
+      before(:each) do
+        User.create(:id => 'user-1', :name => 'Test', :age => 10)
+      end
+      
+      context "by id" do
+        it "should return true if the document exists" do
+          User.exists?('user-1').should == true
+        end
+        
+        it "should return false if the document does not exist" do
+          User.exists?('user-2').should == false
+        end
+      end
+      
+      context "by conditions" do
+        it "should return true if the document exists" do
+          User.exists?(:name => 'Test').should == true
+        end
+        
+        it "should return false if the document does not exist" do
+          User.exists?(:name => 'Nonexistant').should == false
+        end
+      end
+    end
+  end
+end