mongomodel 0.1.6 → 0.2.0

data/spec/mongomodel/document/scopes_spec.rb

@@ -2,202 +2,99 @@ 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
+    define_class(:Post, Document)
     
-    describe "#with_scope" do
-      define_class(:Article, Document) do
-        property :title, String
-        property :author, String
-      end
+    describe "#scoped" do
+      subject { Post.scoped }
       
-      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 be_an_instance_of(MongoModel::Scope) }
       
-      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
+      it "should set the target class" do
+        subject.klass.should == Post
       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'
-        })
+      context "with default scope(s) set" do
+        define_class(:Post, Document) do
+          default_scope order(:title.asc)
+          default_scope limit(5)
+        end
         
-        Article.with_exclusive_scope(:find => { :conditions => { :title => 'Hello World' }, :limit => 10 }) do
-          Article.find(:all, :conditions => { :author => 'Editor' }, :order => 'title ASC')
+        it "should return the default scope" do
+          scope = Post.scoped
+          scope.order_values.should == [:title.asc]
+          scope.limit_value.should == 5
         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)
+      context "within a with_scope block" do
+        it "should return the current scope" do
+          Post.class_eval do
+            with_scope(where(:published => true)) do
+              scoped.where_values.should == [{:published => true}]
+            end
           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)
+      context "within nested with_scope blocks" do
+        it "should return the merged scope" do
+          Post.class_eval do
+            with_scope(where(:published => true)) do
+              with_scope(limit(5)) do
+                scoped.where_values.should == [{:published => true}]
+                scoped.limit_value.should == 5
+              end
+            end
+          end
         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) }
+    describe "#scope" do
+      it "should create a method returning the scope" do
+        Post.class_eval do
+          scope :published, where(:published => true)
+        end
         
-        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
+        scope = Post.published
+        scope.should be_an_instance_of(MongoModel::Scope)
+        scope.where_values.should == [{:published => true}]
       end
       
-      describe "an exclusive scope" do
-        it "should override non-exclusive scopes" do
-          Post.should_find_with({})
-          Post.published.exclusive.all
+      it "should create parameterized method returning the scope when given a lambda" do
+        Post.class_eval do
+          scope :latest, lambda { |num| order(:created_at.desc).limit(num) }
         end
+        
+        scope = Post.latest(4)
+        scope.order_values.should == [:created_at.desc]
+        scope.limit_value.should == 4
       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
+      it "should allow existing scopes to be built upon" do
+        Post.class_eval do
+          scope :recent, order(:created_at.desc).limit(5)
+          scope :recently_published, recent.where(:published => true)
         end
+        
+        scope = Post.recently_published
+        scope.where_values.should == [{:published => true}]
+        scope.order_values.should == [:created_at.desc]
+        scope.limit_value.should == 5
       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 } }
+    describe "named scopes" do
+      define_class(:Post, Document) do
+        scope :published, where(:published => true)
+        scope :recent, order(:created_at.desc).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 == {}
+      it "should be chainable" do
+        scope = Post.published.recent
+        scope.where_values.should == [{:published => true}]
+        scope.order_values.should == [:created_at.desc]
+        scope.limit_value.should == 5
       end
     end
   end

data/spec/mongomodel/support/mongo_operator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module MongoModel
+  describe MongoOperator do
+    subject { MongoOperator.new(:age, :gt) }
+  
+    it "should convert to mongo selector" do
+      subject.to_mongo_selector(14).should == { '$gt' => 14 }
+    end
+  
+    it "should be equal to a MongoOperator with the same field and operator" do
+      subject.should == MongoOperator.new(:age, :gt)
+    end
+  
+    it "should not be equal to a MongoOperator with a different field/operator" do
+      subject.should_not == MongoOperator.new(:age, :lte)
+      subject.should_not == MongoOperator.new(:date, :gt)
+    end
+  
+    it "should be created from symbol methods" do
+      :age.gt.should == MongoOperator.new(:age, :gt)
+      :date.lte.should == MongoOperator.new(:date, :lte)
+    end
+  
+    it "should be equal within a hash" do
+      { :age.gt => 10 }.should == { :age.gt => 10 }
+    end
+  end
+end

data/spec/mongomodel/support/mongo_options_spec.rb

@@ -142,154 +142,4 @@ module MongoModel
       end
     end
   end
-  
-  describe MongoOrder do
-    def c(field, order)
-      MongoOrder::Clause.new(field, order)
-    end
-    
-    subject { MongoOrder.new(c(:name, :ascending), c(:age, :descending)) }
-    
-    it "should convert to string" do
-      subject.to_s.should == "name ascending, age descending"
-    end
-    
-    describe "#to_sort" do
-      it "should convert to mongo sort array" do
-        model = mock('model', :properties => mock('properties', :[] => nil))
-        subject.to_sort(model).should == [['name', :ascending], ['age', :descending]]
-      end
-    end
-    
-    it "should be reversable" do
-      subject.reverse.should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
-    end
-    
-    it "should equal another order object with identical clauses" do
-      subject.should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
-    end
-    
-    it "should equal another order object with different clauses" do
-      subject.should_not == MongoOrder.new(c(:name, :ascending))
-      subject.should_not == MongoOrder.new(c(:age, :ascending), c(:name, :ascending))
-    end
-    
-    describe "#parse" do
-      it "should not change a MongoOrder" do
-        MongoOrder.parse(subject).should == subject
-      end
-      
-      it "should convert individual clause to MongoOrder" do
-        MongoOrder.parse(c(:name, :ascending)).should == MongoOrder.new(c(:name, :ascending))
-      end
-      
-      it "should convert symbol to MongoOrder" do
-        MongoOrder.parse(:name).should == MongoOrder.new(c(:name, :ascending))
-      end
-      
-      it "should convert array of clauses to MongoOrder" do
-        MongoOrder.parse([c(:name, :ascending), c(:age, :descending)]).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
-      end
-      
-      it "should convert array of symbols to MongoOrder" do
-        MongoOrder.parse([:name, :age]).should == MongoOrder.new(c(:name, :ascending), c(:age, :ascending))
-      end
-      
-      it "should convert array of strings to MongoOrder" do
-        MongoOrder.parse(['name ASC', 'age DESC']).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
-      end
-      
-      it "should convert string (no order specified) to MongoOrder" do
-        MongoOrder.parse('name').should == MongoOrder.new(c(:name, :ascending))
-      end
-      
-      it "should convert string (single order) to MongoOrder" do
-        MongoOrder.parse('name DESC').should == MongoOrder.new(c(:name, :descending))
-      end
-      
-      it "should convert string (multiple orders) to MongoOrder" do
-        MongoOrder.parse('name DESC, age ASC').should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
-      end
-    end
-  end
-  
-  describe MongoOrder::Clause do
-    subject { MongoOrder::Clause.new(:name, :ascending) }
-    
-    it "should convert to string" do
-      subject.to_s.should == "name ascending"
-    end
-    
-    it "should equal another clause with the same field and order" do
-      subject.should == MongoOrder::Clause.new(:name, :ascending)
-    end
-    
-    it "should equal another clause with a different field or order" do
-      subject.should_not == MongoOrder::Clause.new(:age, :ascending)
-      subject.should_not == MongoOrder::Clause.new(:name, :descending)
-    end
-    
-    it "should be reversable" do
-      subject.reverse.should == MongoOrder::Clause.new(:name, :descending)
-    end
-    
-    describe "#to_sort" do
-      context "given property" do
-        it "should use property as value to convert to mongo sort" do
-          property = mock('property', :as => '_name')
-          subject.to_sort(property).should == ['_name', :ascending]
-        end
-      end
-      
-      context "given nil" do
-        it "should convert to mongo sort" do
-          subject.to_sort(nil).should == ['name', :ascending]
-        end
-      end
-    end
-    
-    describe "#parse" do
-      let(:asc) { MongoOrder::Clause.new(:name, :ascending) }
-      let(:desc) { MongoOrder::Clause.new(:name, :descending) }
-      
-      it "should create Clause from string (no order)" do
-        MongoOrder::Clause.parse('name').should == asc
-      end
-      
-      it "should create Clause from string (with order)" do
-        MongoOrder::Clause.parse('name ASC').should == asc
-        MongoOrder::Clause.parse('name asc').should == asc
-        MongoOrder::Clause.parse('name ascending').should == asc
-        MongoOrder::Clause.parse('name DESC').should == desc
-        MongoOrder::Clause.parse('name desc').should == desc
-        MongoOrder::Clause.parse('name descending').should == desc
-      end
-    end
-  end
-  
-  describe MongoOperator do
-    subject { MongoOperator.new(:age, :gt) }
-    
-    it "should convert to mongo selector" do
-      subject.to_mongo_selector(14).should == { '$gt' => 14 }
-    end
-    
-    it "should be equal to a MongoOperator with the same field and operator" do
-      subject.should == MongoOperator.new(:age, :gt)
-    end
-    
-    it "should not be equal to a MongoOperator with a different field/operator" do
-      subject.should_not == MongoOperator.new(:age, :lte)
-      subject.should_not == MongoOperator.new(:date, :gt)
-    end
-    
-    it "should be created from symbol methods" do
-      :age.gt.should == MongoOperator.new(:age, :gt)
-      :date.lte.should == MongoOperator.new(:date, :lte)
-    end
-    
-    it "should be equal within a hash" do
-      { :age.gt => 10 }.should == { :age.gt => 10 }
-    end
-  end
 end