mongoid 1.2.14 → 1.9.0

data/spec/unit/mongoid/memoization_spec.rb

@@ -1,75 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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/scope_spec.rb

@@ -1,240 +0,0 @@
-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

data/spec/unit/mongoid/state_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::State do
-
-  describe "#new_record?" do
-
-    context "when the object has been saved" do
-
-      before do
-        @person = Person.new(:_id => "1")
-      end
-
-      it "returns false" do
-        @person.new_record?.should be_false
-      end
-
-    end
-
-    context "when the object has not been saved" do
-
-      before do
-        @person = Person.new
-      end
-
-      it "returns true" do
-        @person.new_record?.should be_true
-      end
-
-    end
-
-  end
-
-  describe "#persisted?" do
-
-    before do
-      @person = Person.new
-    end
-
-    it "delegates to new_record?" do
-      @person.persisted?.should be_false
-    end
-  end
-
-  describe "destroyed?" do
-
-    before do
-      @person = Person.new
-    end
-
-    context "when destroyed is true" do
-
-      before do
-        @person.destroyed = true
-      end
-
-      it "returns true" do
-        @person.destroyed?.should be_true
-      end
-    end
-
-    context "when destroyed is false" do
-
-      before do
-        @person.destroyed = false
-      end
-
-      it "returns true" do
-        @person.destroyed?.should be_false
-      end
-    end
-
-    context "when destroyed is nil" do
-
-      before do
-        @person.destroyed = nil
-      end
-
-      it "returns false" do
-        @person.destroyed?.should be_false
-      end
-    end
-  end
-end