mongoid-locomotive 2.0.0.beta9

data/spec/unit/mongoid/criterion/complex_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Mongoid::Criterion::Complex do
+
+  let(:complex) { Mongoid::Criterion::Complex.new(:key => :field, :operator => "$gt") }
+
+  describe "#initialize" do
+
+    it "sets the key" do
+      complex.key.should == :field
+    end
+
+    it "sets the operator" do
+      complex.operator.should == "$gt"
+    end
+  end
+end

data/spec/unit/mongoid/criterion/exclusion_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+describe Mongoid::Criterion::Exclusion do
+
+  before do
+    @criteria = Mongoid::Criteria.new(Person)
+    @canvas_criteria = Mongoid::Criteria.new(Canvas)
+  end
+
+  describe "#excludes" do
+
+    it "adds the $ne query to the selector" do
+      @criteria.excludes(:title => "Bad Title", :text => "Bad Text")
+      @criteria.selector.should ==
+        {
+          :title =>
+            { "$ne" => "Bad Title"},
+          :text =>
+            { "$ne" => "Bad Text" }
+        }
+    end
+
+    it "returns self" do
+      @criteria.excludes(:title => "Bad").should == @criteria
+    end
+
+    context "when passing an id" do
+
+      it "accepts id" do
+        @criteria.excludes(:id => "1")
+        @criteria.selector.should ==
+          {
+            :_id => { "$ne" => "1" }
+          }
+      end
+
+      it "accepts _id" do
+        @criteria.excludes(:_id => "1")
+        @criteria.selector.should ==
+          {
+            :_id => { "$ne" => "1" }
+          }
+      end
+    end
+
+    context "when existing ne criteria exists" do
+
+      before do
+        @criteria.excludes(:title => "Bad Title")
+        @criteria.excludes(:text => "Bad Text")
+      end
+
+      it "appends to the selector" do
+        @criteria.selector.should ==
+          {
+            :title =>
+              { "$ne" => "Bad Title"},
+            :text =>
+              { "$ne" => "Bad Text" }
+          }
+      end
+    end
+  end
+
+  describe "#not_in" do
+
+    it "adds the exclusion to the selector" do
+      @criteria.not_in(:title => ["title1", "title2"], :text => ["test"])
+      @criteria.selector.should == {
+        :title => { "$nin" => ["title1", "title2"] },
+        :text => { "$nin" => ["test"] }
+      }
+    end
+
+    it "returns self" do
+      @criteria.not_in(:title => ["title1"]).should == @criteria
+    end
+
+    context "when existing nin criteria exists" do
+
+      before do
+        @criteria.not_in(:title => ["title1", "title2"])
+        @criteria.not_in(:title => ["title3"], :text => ["test"])
+      end
+
+      it "appends to the nin selector" do
+        @criteria.selector.should == {
+          :title => { "$nin" => ["title1", "title2", "title3"] },
+          :text => { "$nin" => ["test"] }
+        }
+      end
+    end
+  end
+
+  describe "#only" do
+
+    context "when args are provided" do
+
+      it "adds the options for limiting by fields" do
+        @criteria.only(:title, :text)
+        @criteria.options.should == { :fields => [ :title, :text ] }
+      end
+
+      it "returns self" do
+        @criteria.only.should == @criteria
+      end
+
+    end
+
+    context "when no args provided" do
+
+      it "does not add the field option" do
+        @criteria.only
+        @criteria.options[:fields].should be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/criterion/inclusion_spec.rb

@@ -0,0 +1,274 @@
+require "spec_helper"
+
+describe Mongoid::Criterion::Inclusion do
+
+  before do
+    @criteria = Mongoid::Criteria.new(Person)
+    @canvas_criteria = Mongoid::Criteria.new(Canvas)
+  end
+
+  describe "#all" do
+
+    it "adds the $all query to the selector" do
+      @criteria.all(:title => ["title1", "title2"])
+      @criteria.selector.should ==
+        {
+          :title => { "$all" => ["title1", "title2"] }
+        }
+    end
+
+    it "returns self" do
+      @criteria.all(:title => [ "title1" ]).should == @criteria
+    end
+
+    context "when all criteria exists" do
+
+      before do
+        @criteria.all(:title => ["title1", "title2"])
+        @criteria.all(:title => ["title3"], :another => ["value"])
+      end
+
+      it "appends to the existing criteria" do
+        @criteria.selector.should ==
+          {
+            :title => { "$all" => [ "title1", "title2", "title3" ] },
+            :another => { "$all" => [ "value" ] }
+          }
+      end
+    end
+  end
+
+  describe "#and" do
+
+    context "when provided a hash" do
+
+      it "adds the clause to the selector" do
+        @criteria.and(:title => "Title", :text => "Text")
+        @criteria.selector.should ==
+          {
+            :title => "Title",
+            :text => "Text"
+          }
+      end
+
+    end
+
+    context "when provided a string" do
+
+      it "adds the $where clause to the selector" do
+        @criteria.and("this.date < new Date()")
+        @criteria.selector.should ==
+          {
+            "$where" => "this.date < new Date()"
+          }
+      end
+
+    end
+
+    it "returns self" do
+      @criteria.and.should == @criteria
+    end
+
+  end
+
+  describe "#in" do
+
+    it "adds the $in clause to the selector" do
+      @criteria.in(:title => ["title1", "title2"], :text => ["test"])
+      @criteria.selector.should ==
+        {
+          :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
+        }
+    end
+
+    it "#any_in is aliased to #in" do
+      @criteria.any_in(:title => ["title1", "title2"], :text => ["test"])
+      @criteria.selector.should ==
+        {
+          :title => { "$in" => ["title1", "title2"] }, :text => { "$in" => ["test"] }
+        }
+    end
+
+    it "returns self" do
+      @criteria.in(:title => ["title1"]).should == @criteria
+    end
+
+    context "when existing in criteria exists" do
+
+      before do
+        @criteria.in(:title => ["title1", "title2"])
+        @criteria.in(:title => ["title3"], :text => ["test"])
+      end
+
+      it "appends to the existing criteria" do
+        @criteria.selector.should ==
+          {
+            :title => { "$in" => ["title1", "title2", "title3"] }, :text => { "$in" => ["test"] }
+          }
+      end
+    end
+  end
+
+  describe "#near" do
+
+    it "adds the $near modifier to the selector" do
+      @criteria.near(:field => [ 72, -44 ])
+      @criteria.selector.should ==
+        { :field => { "$near" => [ 72, -44 ] } }
+    end
+  end
+
+  describe "#where" do
+
+    context "when provided a hash" do
+
+      context "with simple hash keys" do
+
+        it "adds the clause to the selector" do
+          @criteria.where(:title => "Title", :text => "Text")
+          @criteria.selector.should ==
+            { :title => "Title", :text => "Text" }
+        end
+
+      end
+
+      context "with complex criterion" do
+
+        context "#all" do
+
+          it "returns those matching an all clause" do
+            @criteria.where(:title.all => ["Sir"])
+            @criteria.selector.should ==
+              { :title => { "$all" => ["Sir"] } }
+          end
+
+        end
+
+        context "#exists" do
+
+          it "returns those matching an exists clause" do
+            @criteria.where(:title.exists => true)
+            @criteria.selector.should ==
+              { :title => { "$exists" => true } }
+          end
+
+        end
+
+        context "#gt" do
+
+          it "returns those matching a gt clause" do
+            @criteria.where(:age.gt => 30)
+            @criteria.selector.should ==
+              { :age => { "$gt" => 30 } }
+          end
+
+        end
+
+        context "#gte" do
+
+          it "returns those matching a gte clause" do
+            @criteria.where(:age.gte => 33)
+            @criteria.selector.should ==
+              { :age => { "$gte" => 33 } }
+          end
+
+        end
+
+        context "#in" do
+
+          it "returns those matching an in clause" do
+            @criteria.where(:title.in => ["Sir", "Madam"])
+            @criteria.selector.should ==
+              { :title => { "$in" => ["Sir", "Madam"] } }
+          end
+
+        end
+
+        context "#lt" do
+
+          it "returns those matching a lt clause" do
+            @criteria.where(:age.lt => 34)
+            @criteria.selector.should ==
+              { :age => { "$lt" => 34 } }
+          end
+
+        end
+
+        context "#lte" do
+
+          it "returns those matching a lte clause" do
+            @criteria.where(:age.lte => 33)
+            @criteria.selector.should ==
+              { :age => { "$lte" => 33 } }
+          end
+
+        end
+
+        context "#ne" do
+
+          it "returns those matching a ne clause" do
+            @criteria.where(:age.ne => 50)
+            @criteria.selector.should ==
+              { :age => { "$ne" => 50 } }
+          end
+
+        end
+
+        context "#near" do
+
+          it "returns those matching a ne clause" do
+            @criteria.where(:location.near => [ 50, 40 ])
+            @criteria.selector.should ==
+              { :location => { "$near" => [ 50, 40 ] } }
+          end
+
+        end
+
+        context "#nin" do
+
+          it "returns those matching a nin clause" do
+            @criteria.where(:title.nin => ["Esquire", "Congressman"])
+            @criteria.selector.should ==
+              { :title => { "$nin" => ["Esquire", "Congressman"] } }
+          end
+
+        end
+
+        context "#size" do
+
+          it "returns those matching a size clause" do
+            @criteria.where(:aliases.size => 2)
+            @criteria.selector.should ==
+              { :aliases => { "$size" => 2 } }
+          end
+
+        end
+
+        context "#near" do
+
+          it "returns those matching a ne clause" do
+            @criteria.where(:location.within => { "$center" => [ [ 50, -40 ], 1 ] })
+            @criteria.selector.should ==
+              { :location => { "$within" => { "$center" => [ [ 50, -40 ], 1 ] } } }
+          end
+        end
+      end
+    end
+
+    context "when provided a string" do
+
+      it "adds the $where clause to the selector" do
+        @criteria.where("this.date < new Date()")
+        @criteria.selector.should ==
+          { "$where" => "this.date < new Date()" }
+      end
+
+    end
+
+    it "returns self" do
+      @criteria.where.should == @criteria
+    end
+
+  end
+
+end

data/spec/unit/mongoid/criterion/optional_spec.rb

@@ -0,0 +1,483 @@
+require "spec_helper"
+
+describe Mongoid::Criterion::Optional do
+
+  before do
+    @criteria = Mongoid::Criteria.new(Person)
+    @canvas_criteria = Mongoid::Criteria.new(Canvas)
+  end
+
+  describe "#ascending" do
+
+    context "when providing a field" do
+
+      before do
+        @criteria.ascending(:title)
+      end
+
+      it "adds the ascending sort criteria" do
+        @criteria.options[:sort].should == [[ :title, :asc ]]
+      end
+    end
+
+    context "when providing nothing" do
+
+      before do
+        @criteria.ascending
+      end
+
+      it "does not modify the sort criteria" do
+        @criteria.options[:sort].should be_nil
+      end
+    end
+  end
+
+  describe "#asc" do
+
+    context "when providing a field" do
+
+      before do
+        @criteria.asc(:title, :dob)
+      end
+
+      it "adds the ascending sort criteria" do
+        @criteria.options[:sort].should == [[ :title, :asc ], [ :dob, :asc ]]
+      end
+    end
+
+    context "when providing nothing" do
+
+      before do
+        @criteria.asc
+      end
+
+      it "does not modify the sort criteria" do
+        @criteria.options[:sort].should be_nil
+      end
+    end
+  end
+
+  describe "#cache" do
+
+    it "sets the cache option on the criteria" do
+      @criteria.cache
+      @criteria.options[:cache].should be_true
+    end
+
+    it "returns self" do
+      @criteria.cache.should == @criteria
+    end
+  end
+
+  describe "#cached?" do
+
+    context "when the criteria has a cache option" do
+
+      before do
+        @criteria.cache
+      end
+
+      it "returns true" do
+        @criteria.cached?.should be_true
+      end
+    end
+
+    context "when the criteria has no cache option" do
+
+      it "returns false" do
+        @criteria.cached?.should be_false
+      end
+    end
+  end
+
+  context "when chaining sort criteria" do
+
+    before do
+      @criteria.asc(:title).desc(:dob, :name).order_by(:score.asc)
+    end
+
+    it "does not overwrite any previous criteria" do
+      @criteria.options[:sort].should ==
+        [[ :title, :asc ], [ :dob, :desc ], [ :name, :desc ], [ :score, :asc ]]
+    end
+  end
+
+  describe "#descending" do
+
+    context "when providing a field" do
+
+      before do
+        @criteria.descending(:title)
+      end
+
+      it "adds the descending sort criteria" do
+        @criteria.options[:sort].should == [[ :title, :desc ]]
+      end
+    end
+
+    context "when providing nothing" do
+
+      before do
+        @criteria.descending
+      end
+
+      it "does not modify the sort criteria" do
+        @criteria.options[:sort].should be_nil
+      end
+    end
+  end
+
+  describe "#desc" do
+
+    context "when providing a field" do
+
+      before do
+        @criteria.desc(:title, :dob)
+      end
+
+      it "adds the descending sort criteria" do
+        @criteria.options[:sort].should == [[ :title, :desc ], [ :dob, :desc ]]
+      end
+    end
+
+    context "when providing nothing" do
+
+      before do
+        @criteria.desc
+      end
+
+      it "does not modify the sort criteria" do
+        @criteria.options[:sort].should be_nil
+      end
+    end
+  end
+
+  describe "#enslave" do
+
+    it "sets the enslaved option on the criteria" do
+      @criteria.enslave
+      @criteria.options[:enslave].should be_true
+    end
+
+    it "returns self" do
+      @criteria.enslave.should == @criteria
+    end
+  end
+
+  describe "#extras" do
+
+    context "filtering" do
+
+      context "when page is provided" do
+
+        it "sets the limit and skip options" do
+          @criteria.extras({ :page => "2" })
+          @criteria.page.should == 2
+          @criteria.options.should == { :skip => 20, :limit => 20 }
+        end
+
+      end
+
+      context "when per_page is provided" do
+
+        it "sets the limit and skip options" do
+          @criteria.extras({ :per_page => 45 })
+          @criteria.options.should == { :skip => 0, :limit => 45 }
+        end
+
+      end
+
+      context "when page and per_page both provided" do
+
+        it "sets the limit and skip options" do
+          @criteria.extras({ :per_page => 30, :page => "4" })
+          @criteria.options.should == { :skip => 90, :limit => 30 }
+          @criteria.page.should == 4
+        end
+
+      end
+
+    end
+
+    it "adds the extras to the options" do
+      @criteria.limit(10).extras({ :skip => 10 })
+      @criteria.options.should == { :skip => 10, :limit => 10 }
+    end
+
+    it "returns self" do
+      @criteria.extras({}).should == @criteria
+    end
+
+  end
+
+  describe "#id" do
+
+    context "when passing a single id" do
+
+      context "when the id is a string" do
+
+        it "adds the _id query to the selector" do
+          id = BSON::ObjectID.new.to_s
+          @criteria.id(id)
+          @criteria.selector.should == { :_id => id }
+        end
+
+        it "returns self" do
+          id = BSON::ObjectID.new.to_s
+          @criteria.id(id).should == @criteria
+        end
+      end
+
+      context "when the id is an object id" do
+
+        it "adds the _id query to the selector" do
+          id = BSON::ObjectID.new
+          @criteria.id(id)
+          @criteria.selector.should == { :_id => id }
+        end
+
+        it "returns self" do
+          id = BSON::ObjectID.new
+          @criteria.id(id).should == @criteria
+        end
+      end
+
+    end
+
+    context "when passing in an array of ids" do
+
+      before do
+        @ids = []
+        3.times { @ids << BSON::ObjectID.new.to_s }
+      end
+
+      it "adds the _id query to the selector" do
+        @criteria.id(@ids)
+        @criteria.selector.should ==
+          { :_id => { "$in" => @ids } }
+      end
+
+    end
+
+  end
+
+  describe "#limit" do
+
+    context "when value provided" do
+
+      it "adds the limit to the options" do
+        @criteria.limit(100)
+        @criteria.options.should == { :limit => 100 }
+      end
+
+    end
+
+    context "when value not provided" do
+
+      it "defaults to 20" do
+        @criteria.limit
+        @criteria.options.should == { :limit => 20 }
+      end
+
+    end
+
+    it "returns self" do
+      @criteria.limit.should == @criteria
+    end
+
+  end
+
+  describe "#offset" do
+
+    context "when the per_page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :per_page => 20, :page => 3 })
+      end
+
+      it "returns the per_page option" do
+        @criteria.offset.should == 40
+      end
+
+    end
+
+    context "when the skip option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :skip => 20 })
+      end
+
+      it "returns the skip option" do
+        @criteria.offset.should == 20
+      end
+
+    end
+
+    context "when an argument is provided" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person)
+        @criteria.offset(40)
+      end
+
+      it "delegates to skip" do
+        @criteria.options[:skip].should == 40
+      end
+
+    end
+
+    context "when no option exists" do
+
+      context "when page option exists" do
+
+        before do
+          @criteria = Mongoid::Criteria.new(Person).extras({ :page => 2 })
+        end
+
+        it "adds the skip option to the options and returns it" do
+          @criteria.offset.should == 20
+          @criteria.options[:skip].should == 20
+        end
+
+      end
+
+      context "when page option does not exist" do
+
+        before do
+          @criteria = Mongoid::Criteria.new(Person)
+        end
+
+        it "returns nil" do
+          @criteria.offset.should be_nil
+          @criteria.options[:skip].should be_nil
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#order_by" do
+
+    context "when field names and direction specified" do
+
+      before do
+        @criteria.order_by([[:title, :asc]]).order_by([[:text, :desc]])
+      end
+
+      it "adds the sort to the options" do
+        @criteria.options.should == { :sort => [[:title, :asc], [:text, :desc]] }
+      end
+    end
+
+    context "when providing a hash of options" do
+
+      before do
+        @criteria.order_by(:title => :asc, :text => :desc)
+      end
+
+      it "adds the sort to the options" do
+        @criteria.options[:sort].should include([:title, :asc], [:text, :desc])
+      end
+    end
+
+    context "when providing multiple symbols" do
+
+      before do
+        @criteria.order_by(:title.asc, :text.desc)
+      end
+
+      it "adds the sort to the options" do
+        @criteria.options.should == { :sort => [[:title, :asc], [:text, :desc]] }
+      end
+    end
+
+    it "returns self" do
+      @criteria.order_by.should == @criteria
+    end
+
+  end
+
+  describe "#page" do
+
+    context "when the page option exists" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person).extras({ :page => 5 })
+      end
+
+      it "returns the page option" do
+        @criteria.page.should == 5
+      end
+
+    end
+
+    context "when the page option does not exist" do
+
+      before do
+        @criteria = Mongoid::Criteria.new(Person)
+      end
+
+      it "returns 1" do
+        @criteria.page.should == 1
+      end
+
+    end
+
+  end
+
+  describe "#skip" do
+
+    context "when value provided" do
+
+      it "adds the skip value to the options" do
+        @criteria.skip(20)
+        @criteria.options.should == { :skip => 20 }
+      end
+
+    end
+
+    context "when value not provided" do
+
+      it "defaults to zero" do
+        @criteria.skip
+        @criteria.options.should == { :skip => 0 }
+      end
+
+    end
+
+    it "returns self" do
+      @criteria.skip.should == @criteria
+    end
+
+  end
+
+  describe "#type" do
+
+    context "when the type is a string" do
+
+      it "adds the _type query to the selector" do
+        @criteria.type('Browser')
+        @criteria.selector.should == { :_type => { '$in' => ['Browser'] } }
+      end
+
+      it "returns self" do
+        @criteria.type('Browser').should == @criteria
+      end
+    end
+
+    context "when the type is an Array of type" do
+
+      it "adds the _type query to the selector" do
+        @criteria.type(['Browser', 'Firefox'])
+        @criteria.selector.should == { :_type => { '$in' => ['Browser', 'Firefox'] } }
+      end
+
+      it "returns self" do
+        @criteria.type(['Browser', 'Firefox']).should == @criteria
+      end
+    end
+
+  end
+end