mongoid 2.0.0.alpha → 2.0.0.beta.5

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/observable_spec.rb

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

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

@@ -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