mongoid 1.9.5 → 2.0.0.alpha

data/spec/unit/mongoid/memoization_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Mongoid::Memoization do
+
+  let(:memo) { "Memo" }
+
+  before do
+    @person = Person.new
+  end
+
+  describe "#memoized" do
+
+    context "when variable has been defined" do
+
+      before do
+        @person.instance_variable_set("@memo", memo)
+      end
+
+      it "returns the memoized value" do
+        @person.memoized(:memo) { nil }.should == memo
+      end
+
+    end
+
+    context "when variable has not been defined" do
+
+      it "returns the new value" do
+        @person.memoized(:memo) { memo }.should == memo
+      end
+
+      it "memoizes the new value" do
+        @person.memoized(:memo) { memo }
+        @person.instance_variable_get("@memo").should == memo
+      end
+
+    end
+
+  end
+
+  describe "#reset" do
+
+    context "when variable has been defined" do
+
+      before do
+        @person.instance_variable_set("@memo", memo)
+      end
+
+      it "removes the memoized value" do
+        @person.reset(:memo) { nil }
+        @person.instance_variable_defined?("@memo").should be_false
+      end
+
+      it "returns the new value" do
+        @person.reset(:memo) { memo }.should == memo
+      end
+
+    end
+
+    context "when variable has not been defined" do
+
+      it "memoizes the new value" do
+        @person.reset(:memo) { memo }
+        @person.instance_variable_get("@memo").should == memo
+      end
+
+      it "returns the value" do
+        @person.reset(:memo) { memo }.should == memo
+      end
+
+    end
+
+
+  end
+
+end

data/spec/unit/mongoid/named_scope_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Mongoid::NamedScope do
+
+  class Player
+    include Mongoid::Document
+    field :active, :type => Boolean
+    field :frags, :type => Integer
+    field :deaths, :type => Integer
+    field :status
+
+    named_scope :active, criteria.where(:active => true) do
+      def extension
+        "extension"
+      end
+    end
+    named_scope :inactive, :where => { :active => false }
+    named_scope :frags_over, lambda { |count| { :where => { :frags.gt => count } } }
+    named_scope :deaths_under, lambda { |count| criteria.where(:deaths.lt => count) }
+    scope :deaths_over, lambda { |count| criteria.where(:deaths.gt => count) }
+
+    class << self
+      def alive
+        criteria.where(:status => "Alive")
+      end
+    end
+  end
+
+  describe ".named_scope" do
+
+    it "adds a class method for the scope" do
+      Player.should respond_to(:active)
+    end
+
+    it "adds the scope to the scopes" do
+      Player.scopes.should include(:active)
+    end
+
+    context "when options are a hash" do
+
+      it "adds the selector to the scope" do
+        Player.inactive.selector[:active].should be_false
+      end
+
+    end
+
+    context "when options are a criteria" do
+
+      it "adds the selector to the scope" do
+        Player.active.selector[:active].should be_true
+      end
+
+    end
+
+    context "when options are a proc" do
+
+      context "when the proc delegates to a hash" do
+
+        it "adds the selector to the scope" do
+          Player.frags_over(50).selector[:frags].should == { "$gt" => 50 }
+        end
+
+      end
+
+      context "when the proc delegates to a criteria" do
+
+        it "adds the selector to the scope" do
+          Player.deaths_under(40).selector[:deaths].should == { "$lt" => 40 }
+        end
+
+      end
+
+    end
+
+    context "when a block is supplied" do
+
+      it "adds a class method for the scope" do
+        Player.should respond_to(:deaths_over)
+      end
+
+      it "adds the scope to the scopes" do
+        Player.scopes.should include(:deaths_over)
+      end
+
+    end
+
+  end
+
+  describe ".scope" do
+
+    it "aliases to named_scope" do
+      Player.should respond_to(:deaths_over)
+    end
+
+  end
+
+  context "chained scopes" do
+
+    context "when chaining two named scopes" do
+
+      it "merges the criteria" do
+        selector = Player.active.frags_over(10).selector
+        selector[:active].should be_true
+        selector[:frags].should == { "$gt" => 10 }
+      end
+
+    end
+
+    context "when chaining named scoped with criteria class methods" do
+
+      it "merges the criteria" do
+        selector = Player.active.frags_over(10).alive.selector
+        selector[:active].should be_true
+        selector[:frags].should == { "$gt" => 10 }
+        selector[:status].should == "Alive"
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/mongoid/observable_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Mongoid::Observable do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:address) do
+    Address.new
+  end
+
+  describe "#add_observer" do
+
+    it "adds an observer to the observer array" do
+      address.add_observer(person)
+      address.observers.first.should == person
+    end
+  end
+
+  describe "#notify_observers" do
+
+    before do
+      address.add_observer(person)
+    end
+
+    context "when observers exist" do
+
+      it "calls update on each observer with the args" do
+        person.expects(:update).with("Testing")
+        address.notify_observers("Testing")
+      end
+    end
+
+    context "when no observers are set up" do
+
+      before do
+        @name = Name.new
+      end
+
+      it "does notthing" do
+        @name.notify_observers("Testing")
+      end
+    end
+  end
+end

data/spec/unit/mongoid/paths_spec.rb

@@ -0,0 +1,124 @@
+require "spec_helper"
+
+describe Mongoid::Paths do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:address) do
+    Address.new(:street => "testing")
+  end
+
+  let(:location) do
+    Location.new
+  end
+
+  describe "#path" do
+
+    context "when the document is a parent" do
+
+      it "returns an empty string" do
+        person.path.should == ""
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      it "returns the inverse_of value of the association" do
+        address.path.should == "addresses"
+      end
+    end
+
+    context "when document embedded multiple levels" do
+
+      before do
+        address.locations << location
+        person.addresses << address
+      end
+
+      it "returns the JSON notation to the document" do
+        location.path.should == "addresses.locations"
+      end
+
+      it "sets the route class instance var" do
+        Location._path.should == "addresses.locations"
+      end
+    end
+  end
+
+  describe "#selector" do
+
+    context "when the document is a parent" do
+
+      it "returns an id selector" do
+        person.selector.should == { "_id" => person.id }
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      it "returns the association with id selector" do
+        address.selector.should == { "_id" => person.id, "addresses._id" => address.id }
+      end
+    end
+
+    context "when document embedded multiple levels" do
+
+      before do
+        address.locations << location
+        person.addresses << address
+      end
+
+      it "returns the JSON notation to the document with ids" do
+        location.selector.should ==
+          { "_id" => person.id, "addresses._id" => address.id, "addresses.locations._id" => location.id }
+      end
+    end
+  end
+
+  describe "#position" do
+
+    context "when the document is a parent" do
+
+      it "returns an empty string" do
+        person.position.should == ""
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      it "returns the path plus $" do
+        address.position.should == "addresses.$"
+      end
+    end
+
+    context "when document embedded multiple levels" do
+
+      before do
+        address.locations << location
+        person.addresses << address
+      end
+
+      it "returns the path plus $" do
+        location.position.should == "addresses.locations.$"
+      end
+
+      it "sets the matcher class instance var" do
+        Location._position.should == "addresses.locations.$"
+      end
+    end
+  end
+end

data/spec/unit/mongoid/scope_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+describe Mongoid::Scope do
+
+  before do
+    Person.delete_all
+  end
+
+  describe "#==" do
+
+    before do
+      @scope = Mongoid::Scope.new(Person, {})
+    end
+
+    context "when other is a scope" do
+
+      context "when the parent and conditions match" do
+
+        before do
+          @other = Mongoid::Scope.new(Person, {})
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the conditions do not match" do
+
+        before do
+          @other = Mongoid::Scope.new(Person, { :where => { :field => "value" } })
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+      end
+
+    end
+
+    context "when other is an enumerable" do
+
+      context "when the array contents are equal" do
+
+        before do
+          @other = []
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the array contents are not equal" do
+
+        before do
+          @other = [ stub ]
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+
+      end
+    end
+
+    context "when other is an invalid type" do
+
+      it "returns false" do
+        Mongoid::Scope.new(Person, {}).should_not == stub
+      end
+
+    end
+
+  end
+
+  describe ".initialize" do
+
+    before do
+      @parent = Mongoid::Scope.new(Person, {})
+    end
+
+    context "when parent is another scope" do
+
+      before do
+        @scope = Mongoid::Scope.new(@parent, {})
+      end
+
+      it "does not set the class" do
+        @scope.klass.should be_nil
+      end
+
+    end
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {})
+      end
+
+      it "returns the parent class" do
+        @scope.klass.should == Person
+      end
+
+    end
+
+    context "when a block is passed in" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {}) do
+          def extended
+            "extended"
+          end
+        end
+      end
+
+      it "extends the block" do
+        @scope.extended.should == "extended"
+      end
+
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    context "when a scope has been defined for the name" do
+
+      before do
+        @defined = mock
+        @class = mock
+        @class.expects(:scopes).twice.returns({ :testing => @defined })
+        @scope = Mongoid::Scope.new(@class, {})
+      end
+
+      it "calls the matching scope" do
+        @defined.expects(:call).with(@scope, "Testing").returns(true)
+        @scope.testing("Testing").should be_true
+      end
+
+    end
+
+    context "when a scope is not defined for the name" do
+
+      context "when the scope is the parent" do
+
+        before do
+          @target = mock
+          @scope = Mongoid::Scope.new(Person, {})
+          @scope.instance_variable_set("@target", @target)
+        end
+
+        it "sends the call to the target" do
+          @target.expects(:testing).with("Testing").returns(true)
+          @scope.testing("Testing").should be_true
+        end
+
+      end
+
+      context "when the scope is not the parent" do
+
+        before do
+          @parent = mock
+          @criteria = mock
+          @parent.expects(:scopes).returns({})
+          @parent.expects(:is_a?).with(Mongoid::Scope).returns(true)
+          @parent.expects(:fuse)
+          @scope = Mongoid::Scope.new(@parent, {})
+        end
+
+        it "creates a criteria from the parent scope" do
+          @parent.expects(:testing).returns(true)
+          @scope.testing.should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#respond_to?" do
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Mongoid::Scope.new(Person, {})
+      end
+
+      it "delegates to the target" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+    context "when parent is a scope" do
+
+      before do
+        @parent = Mongoid::Scope.new(Person, {})
+        @scope = Mongoid::Scope.new(@parent, {})
+      end
+
+      it "delegates to the parent" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+  end
+
+  describe "#scopes" do
+
+    before do
+      @parent = mock
+      @scope = Mongoid::Scope.new(@parent, {})
+    end
+
+    it "delegates to the parent" do
+      @parent.expects(:scopes).returns({})
+      @scope.scopes.should == {}
+    end
+
+  end
+
+  describe "#target" do
+
+    before do
+      @scope = Mongoid::Scope.new(Person, { :where => { :title => "Sir" } })
+    end
+
+    it "returns the conditions criteria" do
+      @scope.target.selector.should ==
+        { :title => "Sir" }
+    end
+
+  end
+
+end