mongoid-pre 2.0.0.beta1

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(:observe).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/persistence/insert_spec.rb

@@ -0,0 +1,175 @@
+require "spec_helper"
+
+describe Mongoid::Persistence::Insert do
+
+  let(:document) do
+    Patient.new(:title => "Mr")
+  end
+
+  let(:address) do
+    Address.new(:street => "Oxford St")
+  end
+
+  let(:collection) do
+    stub.quacks_like(Mongoid::Collection.allocate)
+  end
+
+  before do
+    document.stubs(:collection).returns(collection)
+  end
+
+  describe "#initialize" do
+
+    let(:insert) do
+      Mongoid::Persistence::Insert.new(document)
+    end
+
+    it "sets the document" do
+      insert.document.should == document
+    end
+
+    it "sets the collection" do
+      insert.collection.should == document.collection
+    end
+
+    it "defaults validation to true" do
+      insert.validate.should == true
+    end
+
+    it "sets the options" do
+      insert.options.should ==
+        { :safe => Mongoid.persist_in_safe_mode }
+    end
+  end
+
+  describe "#persist" do
+
+    def root_set_expectation
+      lambda {
+        collection.expects(:insert).with(
+          document.raw_attributes,
+          :safe => true
+        ).returns("Object")
+      }
+    end
+
+    def root_push_expectation
+      lambda {
+        collection.expects(:update).with(
+          { "_id" => document.id },
+          { "addresses" => { "$push" => address.raw_attributes } },
+          :safe => true
+        ).returns("Object")
+      }
+    end
+
+    let(:insert) do
+      Mongoid::Persistence::Insert.new(document)
+    end
+
+    context "when the document is valid" do
+
+      it "inserts the new document" do
+        root_set_expectation.call
+        insert.persist
+      end
+
+      it "returns the document" do
+        root_set_expectation.call
+        insert.persist.should == document
+      end
+
+      it "sets new_record to false" do
+        root_set_expectation.call
+        insert.persist
+        document.new_record?.should == false
+      end
+    end
+
+    context "when the document is not valid" do
+
+      before do
+        document.stubs(:valid?).returns(false)
+      end
+
+      it "returns the document" do
+        insert.persist.should == document
+      end
+
+      it "leaves the document as a new record" do
+        insert.persist
+        document.new_record?.should == true
+      end
+    end
+
+    context "when not validating" do
+
+      before do
+        insert.instance_variable_set(:@validate, false)
+        document.stubs(:valid?).returns(false)
+      end
+
+      after do
+        insert.instance_variable_set(:@validate, true)
+      end
+
+      it "inserts the document in the database" do
+        root_set_expectation.call
+        insert.persist
+        document.new_record?.should == false
+      end
+    end
+
+    context "when the document is embedded" do
+
+      context "when the embedded document is an embeds_one" do
+
+        context "when the parent is new" do
+
+          it "notifies its changes to parent and inserts the parent"
+
+        end
+
+        context "when the parent is not new" do
+
+          it "performs an in place $set on the embedded document"
+        end
+      end
+
+      context "when the embedded document is an embeds_many" do
+
+        before do
+          document.addresses << address
+        end
+
+        context "when the parent is new" do
+
+          let(:insert) do
+            Mongoid::Persistence::Insert.new(address)
+          end
+
+          it "notifies its changes to the parent and inserts the parent" do
+            root_set_expectation.call
+            insert.persist.should == address
+          end
+        end
+
+        context "when the parent is not new" do
+
+          let(:insert) do
+            Mongoid::Persistence::Insert.new(address)
+          end
+
+          before do
+            document.instance_variable_set(:@new_record, false)
+          end
+
+          it "performs a $push on the embedded array" do
+            root_push_expectation.call
+            insert.persist.should == address
+          end
+        end
+      end
+    end
+  end
+end