mongodoc 0.2.2 → 0.2.4

data/spec/finders_spec.rb

@@ -7,73 +7,65 @@ describe MongoDoc::Finders do
     key :data
   end
 
-  context ".criteria" do
-    it "creates a new criteria for the document" do
-      FindersTest.criteria.should be_a_kind_of(MongoDoc::Criteria)
-    end
-
-    it "sets the criteria klass" do
-      FindersTest.criteria.klass.should == FindersTest
-    end
-  end
+  let(:criteria) { stub('criteria').as_null_object }
 
   context ".find" do
     before do
-      @criteria = stub('criteria').as_null_object
-      @conditions = {:where => 'this.a > 3'}
-      MongoDoc::Criteria.stub(:translate).and_return(@criteria)
+      FindersTest.stub(:criteria).and_return(criteria)
     end
 
-    it "creates a criteria" do
-      MongoDoc::Criteria.should_receive(:translate).with(FindersTest, @conditions).and_return(@criteria)
-      FindersTest.find(:first, @conditions)
+    it "delegates to id for the criteria" do
+      args = [1, 2, 3]
+      criteria.should_receive(:id).with(*args)
+      FindersTest.find(*args)
     end
+  end
 
-    [:all, :first, :last].each do |which|
-      it "calls #{which} on the criteria" do
-        @criteria.should_receive(which)
-        FindersTest.find(which, @conditions)
-      end
+  context ".find_all" do
+    it "delegates to an empty criteria" do
+      FindersTest.should_receive(:criteria)
+      FindersTest.find_all
+    end
+
+    it "returns the empty criteria" do
+      FindersTest.stub(:criteria).and_return(criteria)
+      FindersTest.find_all.should == criteria
     end
   end
 
   context ".find_one" do
     context "with an id" do
-      it "calls translate with the id" do
+      it "delegates to translate" do
         id = 'an id'
-        MongoDoc::Criteria.should_receive(:translate).with(FindersTest, id)
+        Mongoid::Criteria.should_receive(:translate).with(FindersTest, id)
         FindersTest.find_one(id)
       end
     end
 
     context "with conditions" do
-      before do
-        @criteria = stub('criteria').as_null_object
-        @conditions = {:where => 'this.a > 3'}
-      end
+      let(:conditions) { {:where => 'this.a > 3'} }
 
       it "calls translate with the conditions" do
-        MongoDoc::Criteria.should_receive(:translate).with(FindersTest, @conditions).and_return(@criteria)
-        FindersTest.find_one(@conditions)
+        Mongoid::Criteria.should_receive(:translate).with(FindersTest, conditions).and_return(criteria)
+        FindersTest.find_one(conditions)
       end
 
-      it "call :one on the result" do
-        MongoDoc::Criteria.stub(:translate).and_return(@criteria)
-        @criteria.should_receive(:one)
-        FindersTest.find_one(@conditions)
+      it "call one on the result" do
+        Mongoid::Criteria.stub(:translate).and_return(criteria)
+        criteria.should_receive(:one)
+        FindersTest.find_one(conditions)
       end
     end
   end
 
   context "all other finders" do
     before do
-      @criteria = stub('criteria').as_null_object
-      MongoDoc::Criteria.stub(:new).and_return(@criteria)
+      FindersTest.stub(:criteria).and_return(criteria)
     end
 
-    [:all, :count, :first, :last].each do |which|
+    %w(count first last).each do |which|
       it "calls #{which} on the new criteria" do
-        @criteria.should_receive(which)
+        criteria.should_receive(which)
         FindersTest.send(which)
       end
     end

data/spec/matchers_spec.rb

@@ -0,0 +1,342 @@
+require "spec_helper"
+
+describe MongoDoc::Matchers do
+
+  class Address
+    include MongoDoc::Matchers
+
+    attr_accessor :number
+    attr_accessor :services
+    attr_accessor :street
+
+    def initialize(attrs = {})
+      attrs.each {|key, value| send("#{key}=", value)}
+    end
+  end
+
+  describe "#matches?" do
+
+    context "when performing simple matching" do
+
+      before do
+        @document = Address.new(:street => "Clarkenwell Road")
+      end
+
+      context "when the attributes match" do
+
+        before do
+          @selector = { :street => "Clarkenwell Road" }
+        end
+
+        it "returns true" do
+          @document.matches?(@selector).should be_true
+        end
+
+      end
+
+      context "when the attributes dont match" do
+
+        before do
+          @selector = { :street => "Broadway Ave" }
+        end
+
+        it "returns false" do
+          @document.matches?(@selector).should be_false
+        end
+
+      end
+
+    end
+
+    context "when performing complex matching" do
+
+      before do
+        @document = Address.new(:services => ["first", "second"], :number => 100)
+      end
+
+      context "with an $all selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$all" => [ "first", "second" ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$all" => [ "first" ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $exists selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$exists" => true } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$exists" => false } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $gt selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$gt" => 50 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$gt" => 200 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $gte selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$gte" => 100 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$gte" => 200 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $in selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$in" => [ 100, 200 ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$in" => [ 200, 300 ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $lt selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$lt" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$lt" => 50 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $lte selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$lte" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$lte" => 50 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $ne selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$ne" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$ne" => 100 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $nin selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$nin" => [ 1, 2, 3 ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$nin" => [ 100 ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $size selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$size" => 2 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$size" => 5 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/spec/scope_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper.rb"))
+
+describe MongoDoc::Scope do
+
+  module Extension
+    def extension_module_method
+      "extension module method"
+    end
+  end
+
+  class ScopeTest
+    include MongoDoc::Document
+
+    key :active
+    key :count
+
+    scope :active, where(:active => true)
+    scope :count_lte_one, where(:count.lte => 1) do
+      def extension_method
+        "extension method"
+      end
+    end
+    scope :count_gt_one, where(:count.gt => 1), :extend => Extension
+    scope :at_least_count, lambda {|count| where(:count.gt => count)}
+  end
+
+  context ".scope" do
+    it "adds the named scope to the hash of scopes" do
+      ScopeTest.scopes.should have_key(:active)
+    end
+
+    it "creates a class method for the named scope" do
+      ScopeTest.should respond_to(:active)
+    end
+  end
+
+  context "accessing a named scope" do
+    it "is a criteria proxy" do
+      MongoDoc::Scope::CriteriaProxy.should === ScopeTest.active
+    end
+
+    it "responds like a criteria" do
+      ScopeTest.active.should respond_to(:selector)
+    end
+
+    it "has set the conditions on the criteria" do
+      ScopeTest.active.selector.should has_entry(:active => true)
+    end
+
+    it "sets the association extension by block" do
+      ScopeTest.count_lte_one.extension_method.should == "extension method"
+    end
+
+    it "sets the association extension by :extend" do
+      ScopeTest.count_gt_one.extension_module_method.should == "extension module method"
+    end
+
+    context "when using a lambda" do
+      it "accepts parameters to the criteria" do
+        ScopeTest.at_least_count(3).selector.should has_entry(:count => {'$gt' => 3})
+      end
+    end
+  end
+
+  context "chained scopes" do
+    it "is a criteria proxy" do
+      MongoDoc::Scope::CriteriaProxy.should === ScopeTest.active.count_gt_one
+    end
+
+    it "responds like a criteria" do
+      ScopeTest.active.count_gt_one.should respond_to(:selector)
+    end
+
+    it "merges the criteria" do
+      ScopeTest.active.count_gt_one.selector.should has_entry(:count => {'$gt' => 1}, :active => true)
+    end
+  end
+end
+