mongomodel 0.1

data/spec/mongomodel/document/indexes_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module MongoModel
+  describe Document do
+    describe "indexes" do
+      define_class(:Article, Document) do
+        property :title, String
+        property :age, Integer
+      end
+    
+      def subclass(klass)
+        Class.new(klass)
+      end
+    
+      it "should have an indexes collection" do
+        Article.indexes.should be_an_instance_of(Array)
+      end
+    
+      it "should inherit indexes from parent classes" do
+        index = mock('index')
+        Article.indexes << index
+        subclass(Article).indexes.should include(index)
+      end
+    
+      describe "#index" do
+        it "should add an index to the indexes collection" do
+          Article.index :title, :unique => true
+          Article.indexes.last.should == Index.new(:title, :unique => true)
+        end
+      
+        it "should mark indexes as uninitialized" do
+          Article.ensure_indexes!
+        
+          Article.indexes_initialized?.should be_true
+          Article.index :age
+          Article.indexes_initialized?.should be_false
+        end
+      end
+    
+      describe "#ensure_indexes!" do
+        before(:each) do
+          Article.index :title, :unique => true
+          Article.index :age => :descending
+        end
+      
+        it "should create indexes on the collection" do
+          Article.collection.should_receive(:create_index).with(:_type)
+          Article.collection.should_receive(:create_index).with(:title, true)
+          Article.collection.should_receive(:create_index).with([[:age, Mongo::DESCENDING]])
+          Article.ensure_indexes!
+        end
+      
+        it "should mark indexes as initialized" do
+          Article.indexes_initialized?.should be_false
+          Article.ensure_indexes!
+          Article.indexes_initialized?.should be_true
+        end
+      end
+    
+      describe "#_find" do
+        it "should run ensure_indexes!" do
+          Article.should_receive(:ensure_indexes!)
+          Article.find(:first)
+        end
+      
+        it "should rerun ensure_indexes! if indexes are initialized" do
+          Article.ensure_indexes!
+          Article.should_not_receive(:ensure_indexes!)
+          Article.find(:first)
+        end
+      end
+    end
+    
+    describe "index shortcuts" do
+      define_class(:TestDocument, Document)
+      
+      describe ":index => true" do
+        it "should add an index on the property" do
+          TestDocument.should_receive(:index).with(:title)
+          TestDocument.property :title, String, :index => true
+        end
+      end
+    end
+  end
+  
+  describe Index do
+    it "should convert index with single key to arguments for Mongo::Collection#create_index" do
+      Index.new(:title).to_args.should == [:title]
+    end
+    
+    it "should convert nested index with single key to arguments for Mongo::Collection#create_index" do
+      Index.new('page.title').to_args.should == [:'page.title']
+    end
+    
+    it "should convert index with unique option to arguments for Mongo::Collection#create_index" do
+      Index.new(:title, :unique => true).to_args.should == [:title, true]
+    end
+    
+    it "should convert index with descending key to arguments for Mongo::Collection#create_index" do
+      Index.new(:title => :descending).to_args.should == [[[:title, Mongo::DESCENDING]]]
+    end
+    
+    it "should convert index with multiple keys to arguments for Mongo::Collection#create_index" do
+      Index.new(:title, :age).to_args.should == [[[:age, Mongo::ASCENDING], [:title, Mongo::ASCENDING]]]
+    end
+    
+    it "should convert index with multiple keys (ascending and descending) to arguments for Mongo::Collection#create_index" do
+      Index.new(:title => :ascending, :age => :descending).to_args.should == [[[:age, Mongo::DESCENDING], [:title, Mongo::ASCENDING]]]
+    end
+    
+    it "should be equal to an equivalent index" do
+      Index.new(:title).should == Index.new(:title)
+      Index.new(:title, :age).should == Index.new(:title => :ascending, :age => :ascending)
+    end
+    
+    it "should not be equal to an non-equivalent index" do
+      Index.new(:title).should_not == Index.new(:age)
+      Index.new(:title, :age).should_not == Index.new(:title => :ascending, :age => :descending)
+    end
+  end
+end

data/spec/mongomodel/document/optimistic_locking_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    describe "optimistic locking" do
+      define_class(:TestDocument, Document)
+      
+      it "should not lock optimistically by default" do
+        TestDocument.locking_enabled?.should be_false
+      end
+      
+      it "should not include a lock version property" do
+        TestDocument.properties.should_not include(:_lock_version)
+      end
+      
+      context "with locking enabled" do
+        define_class(:TestDocument, Document) do
+          property :name, String
+          self.lock_optimistically = true
+        end
+        
+        before(:each) do
+          @fresh = TestDocument.create!(:name => 'Original')
+          @stale = @fresh.dup
+          
+          @fresh.name = 'Changed'
+          @fresh.save!
+        end
+        
+        it "should be enabled" do
+          TestDocument.locking_enabled?.should be_true
+        end
+        
+        it "should define a lock version property" do
+          TestDocument.properties.should include(:_lock_version)
+        end
+        
+        it "should save a fresh document" do
+          @fresh.save.should be_true
+        end
+        
+        it "should save! a fresh document" do
+          @fresh.save!.should be_true
+        end
+        
+        it "should not save a stale document" do
+          @stale.save.should be_false
+          @stale._lock_version.should == 1
+        end
+        
+        it "should raise an error when trying to save! a stale document" do
+          lambda { @stale.save! }.should raise_error(DocumentNotSaved)
+        end
+      end
+    end
+  end
+end

data/spec/mongomodel/document/persistence_spec.rb

@@ -0,0 +1,319 @@
+require 'spec_helper'
+
+module MongoModel
+  describe Document do
+    describe "persistence" do
+      define_class(:User, Document) do
+        property :name, String
+        property :age, Integer
+      end
+      
+      context "an unsaved instance" do
+        subject { User.new(:name => 'Test') }
+
+        it { should be_a_new_record }
+
+        describe "#save" do
+          it "should return true" do
+            subject.save.should == true
+          end
+
+          it "should persist the document to the collection" do
+            subject.save
+
+            doc = User.collection.find_one
+            doc['_id'].to_s.should == subject.attributes[:id]
+            doc['name'].should == 'Test'
+          end
+        end
+
+        context "with a custom id" do
+          subject { User.new(:id => 'custom-id') }
+
+          it "should save the document using the custom id" do
+            subject.save
+            User.collection.find_one['_id'].should == 'custom-id'
+          end
+        end
+      end
+
+      context "a saved instance" do
+        subject { User.new(:name => 'Test') }
+
+        before(:each) { subject.save }
+
+        it { should_not be_a_new_record }
+
+        describe "#save" do
+          it "should return true" do
+            subject.save.should == true
+          end
+
+          it "should not create a new document" do
+            lambda {
+              subject.save
+            }.should_not change(User.collection, :count)
+          end
+
+          it "should update the document attributes" do
+            subject.attributes[:name] = 'Changed'
+            subject.save
+
+            doc = User.collection.find_one
+            doc['name'].should == 'Changed'
+          end
+        end
+      end
+      
+      describe "#collection_name" do
+        it "should infer the default collection name" do
+          User.collection_name.should == 'users'
+        end
+
+        it "should infer the default collection name for namespaced models" do
+          module ::Blog
+            class Post < MongoModel::Document; end
+          end
+
+          ::Blog::Post.collection_name.should == 'blog.posts'
+        end
+
+        it "should allow a custom collection name" do
+          class ::CustomCollectionName < Document
+            self.collection_name = 'foobar'
+          end
+
+          ::CustomCollectionName.collection_name.should == 'foobar'
+        end
+
+        it "should inherit a custom collection name" do
+          class ::CustomCollectionName < Document
+            self.collection_name = 'foobar'
+          end
+          class ::CustomCollectionNameSubclass < ::CustomCollectionName; end
+
+          ::CustomCollectionNameSubclass.collection_name.should == 'foobar'
+        end
+      end
+
+      describe "#collection" do
+        it "should be a mongo collection" do
+          User.collection.should be_a(Mongo::Collection)
+        end
+
+        it "should use the correct collection name" do
+          User.collection.name.should == 'users'
+        end
+      end
+
+      describe "#database" do
+        it "should return the current database" do
+          User.database.should == MongoModel.database
+        end
+      end
+      
+      describe "#create" do
+        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.should_not be_a_new_record
+          end
+
+          it "should yield the instance to a given block before saving" do
+            block_called = false
+
+            User.create 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
+        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
+        end
+      end
+      
+      describe "#delete (class method)" do
+        before(:each) do
+          User.create(:id => 'user-1', :name => 'Test', :age => 10)
+          User.create(:id => 'user-2', :name => 'Another', :age => 20)
+          User.create(:id => 'user-3')
+        end
+
+        it "should delete by id" do
+          User.delete('user-1')
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_true
+        end
+
+        it "should delete by conditions" do
+          User.delete(:age.gt => 15)
+
+          User.exists?('user-2').should be_false
+          User.exists?('user-1').should be_true
+        end
+
+        it "should delete by multiple ids in array" do
+          User.delete(['user-1', 'user-2'])
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_false
+          User.exists?('user-3').should be_true
+        end
+      end
+
+      describe "#delete (instance method)" do
+        before(:each) do
+          @user = User.create(:id => 'user-1')
+          User.create(:id => 'user-2', :name => 'Another')
+        end
+
+        it "should delete the instance from the database" do
+          @user.delete
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_true
+        end
+
+        it "should return the instance" do
+          @user.delete.should == @user
+        end
+
+        it "should freeze the instance" do
+          @user.delete
+          @user.should be_frozen
+        end
+        
+        it "should mark the instance as destroyed" do
+          @user.delete
+          @user.should be_destroyed
+        end
+      end
+
+      describe "#destroy (instance method)" do
+        before(:each) do
+          @user = User.create(:id => 'user-1')
+          User.create(:id => 'user-2', :name => 'Another')
+        end
+
+        it "should delete the instance from the database" do
+          @user.destroy
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_true
+        end
+
+        it "should return the instance" do
+          @user.destroy.should == @user
+        end
+
+        it "should freeze the instance" do
+          @user.destroy
+          @user.should be_frozen
+        end
+        
+        it "should mark the instance as destroyed" do
+          @user.destroy
+          @user.should be_destroyed
+        end
+      end
+
+      describe "#destroy (class method)" do
+        before(:each) do
+          User.create(:id => 'user-1', :name => 'Test', :age => 10)
+          User.create(:id => 'user-2', :name => 'Another', :age => 20)
+          User.create(:id => 'user-3')
+        end
+
+        it "should destroy by id" do
+          User.destroy('user-1')
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_true
+        end
+
+        it "should destroy by conditions" do
+          User.destroy(:age.gt => 15)
+
+          User.exists?('user-2').should be_false
+          User.exists?('user-1').should be_true
+        end
+
+        it "should destroy by multiple ids in array" do
+          User.destroy(['user-1', 'user-2'])
+
+          User.exists?('user-1').should be_false
+          User.exists?('user-2').should be_false
+          User.exists?('user-3').should be_true
+        end
+      end
+      
+      describe "#update_attributes" do
+        let(:user) { User.new(:name => 'Original', :age => 10) }
+        
+        before(:each) { user.update_attributes(:name => 'Changed', :age => 20) }
+        
+        it "should update the attributes" do
+          user.name.should == 'Changed'
+          user.age.should == 20
+        end
+        
+        it "should save the document" do
+          user.should_not be_a_new_record
+        end
+      end
+      
+      describe "#update_attribute" do
+        let(:user) { User.new(:name => 'Original', :age => 10) }
+        
+        before(:each) { user.update_attribute(:name, 'Changed') }
+        
+        it "should update the given attribute" do
+          user.name.should == 'Changed'
+        end
+        
+        it "should save the document" do
+          user.should_not be_a_new_record
+        end
+      end
+    end
+  end
+end