mongoid 3.1.4 → 3.1.5

data/spec/mongoid/atomic/paths/embedded/many_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+describe Mongoid::Atomic::Paths::Embedded::Many do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:address) do
+    Address.new(street: "Strassmannstr.")
+  end
+
+  let(:phone) do
+    Phone.new(number: '+33123456789')
+  end
+
+  before do
+    person.addresses << address
+  end
+
+  let(:many) do
+    described_class.new(address)
+  end
+
+  describe "#delete_modifier" do
+
+    it "returns $pull" do
+      many.delete_modifier.should eq("$pull")
+    end
+  end
+
+  describe "#document" do
+
+    it "returns the document" do
+      many.document.should eq(address)
+    end
+  end
+
+  describe "#insert_modifier" do
+
+    it "returns $push" do
+      many.insert_modifier.should eq("$push")
+    end
+  end
+
+  describe "#path" do
+
+    context "when the document is embedded one level" do
+
+      it "returns the name of the relation" do
+        many.path.should eq("addresses")
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:location) do
+        Location.new(name: "home")
+      end
+
+      before do
+        address.locations << location
+      end
+
+      let(:many) do
+        described_class.new(location)
+      end
+
+      it "returns the nested path to the relation" do
+        many.path.should eq("addresses.locations")
+      end
+    end
+  end
+
+  describe "#position" do
+
+    context "when the document is embedded one level" do
+
+      context "with a relation with :store_as option" do
+        let(:many) do
+          described_class.new(phone)
+        end
+
+        before do
+          person.phones << phone
+        end
+        it "return the name of the store_as in relation" do
+          many.position.should eq("mobile_phones")
+        end
+      end
+
+      it "returns the name of the relation" do
+        many.position.should eq("addresses")
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:location) do
+        Location.new(name: "home")
+      end
+
+      before do
+        address.locations << location
+        address.new_record = false
+        location.new_record = false
+      end
+
+      let(:many) do
+        described_class.new(location)
+      end
+
+      it "returns the nested position to the relation" do
+        many.position.should eq("addresses.0.locations.0")
+      end
+    end
+  end
+
+  describe "#selector" do
+
+    context "when the document is embedded one level" do
+
+      it "returns the the hash with parent selector" do
+        many.selector.should eq(
+          { "_id" => person._id, "addresses._id" => address._id }
+        )
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:location) do
+        Location.new(name: "home")
+      end
+
+      before do
+        address.locations << location
+        address.new_record = false
+        address.post_persist
+        location.new_record = false
+        location.post_persist
+      end
+
+      let(:many) do
+        described_class.new(location)
+      end
+
+      it "returns the hash with all parent selectors" do
+        many.selector.should eq(
+          {
+            "_id" => person._id,
+            "addresses._id" => address._id,
+            "addresses.0.locations._id" => location._id
+          }
+        )
+      end
+    end
+  end
+end

data/spec/mongoid/atomic/paths/embedded/one_spec.rb

@@ -0,0 +1,152 @@
+require "spec_helper"
+
+describe Mongoid::Atomic::Paths::Embedded::One do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:name) do
+    Name.new(first_name: "Syd")
+  end
+
+  before do
+    person.name = name
+  end
+
+  let(:one) do
+    described_class.new(name)
+  end
+
+  describe "#delete_modifier" do
+
+    it "returns $unset" do
+      one.delete_modifier.should eq("$unset")
+    end
+  end
+
+  describe "#document" do
+
+    it "returns the document" do
+      one.document.should eq(name)
+    end
+  end
+
+  describe "#insert_modifier" do
+
+    it "returns $set" do
+      one.insert_modifier.should eq("$set")
+    end
+  end
+
+  describe "#path" do
+
+    context "when the document is embedded one level" do
+
+      it "returns the name of the relation" do
+        one.path.should eq("name")
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:phone) do
+        Phone.new(number: "404-555-1212")
+      end
+
+      let(:country_code) do
+        CountryCode.new(code: 1)
+      end
+
+      before do
+        phone.country_code = country_code
+        person.phone_numbers << phone
+      end
+
+      let(:one) do
+        described_class.new(country_code)
+      end
+
+      it "returns the nested path to the relation" do
+        one.path.should eq("phone_numbers.country_code")
+      end
+    end
+  end
+
+  describe "#position" do
+
+    context "when the document is embedded one level" do
+
+      it "returns the name of the relation" do
+        one.position.should eq("name")
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:phone) do
+        Phone.new(number: "404-555-1212")
+      end
+
+      let(:country_code) do
+        CountryCode.new(code: 1)
+      end
+
+      before do
+        phone.country_code = country_code
+        person.phone_numbers << phone
+        phone.new_record = false
+      end
+
+      let(:one) do
+        described_class.new(country_code)
+      end
+
+      it "returns the nested position to the relation" do
+        one.position.should eq("phone_numbers.0.country_code")
+      end
+    end
+  end
+
+  describe "#selector" do
+
+    context "when the document is embedded one level" do
+
+      it "returns the the hash with parent selector" do
+        one.selector.should eq({ "_id" => person._id, "name._id" => name._id })
+      end
+    end
+
+    context "when the document is embedded multiple levels" do
+
+      let(:phone) do
+        Phone.new(number: "404-555-1212")
+      end
+
+      let(:country_code) do
+        CountryCode.new(code: 1)
+      end
+
+      before do
+        phone.country_code = country_code
+        person.phone_numbers << phone
+        phone.new_record = false
+        phone.post_persist
+      end
+
+      let(:one) do
+        described_class.new(country_code)
+      end
+
+      it "returns the hash with all parent selectors" do
+        one.selector.should eq(
+          {
+            "_id" => person._id,
+            "phone_numbers._id" => phone._id,
+            "phone_numbers.0.country_code._id" => country_code._id
+          }
+        )
+      end
+    end
+  end
+end

data/spec/mongoid/atomic/paths/root_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe Mongoid::Atomic::Paths::Root do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:root) do
+    described_class.new(person)
+  end
+
+  describe "#document" do
+
+    it "returns the document" do
+      root.document.should eq(person)
+    end
+  end
+
+  describe "#path" do
+
+    it "returns an empty string" do
+      root.path.should be_empty
+    end
+  end
+
+  describe "#position" do
+
+    it "returns an empty string" do
+      root.position.should be_empty
+    end
+  end
+
+  describe "#insert_modifier" do
+
+    let(:address) do
+      person.addresses.build
+    end
+
+    let(:root) do
+      described_class.new(address)
+    end
+
+    it "raises a mixed relations error" do
+      expect { root.insert_modifier }.to raise_error(Mongoid::Errors::InvalidPath)
+    end
+  end
+
+  describe "#selector" do
+
+    context "when using a shard key" do
+
+      let(:profile) do
+        Profile.new(name: "google")
+      end
+
+      let(:root) do
+        described_class.new(profile)
+      end
+
+      it "returns the id and shard key in the hash" do
+        root.selector.should eq({ "_id" => profile.id, "name" => profile.name })
+      end
+    end
+
+    context "when not using a shard key" do
+
+      context "when using object ids" do
+
+        it "returns the hash with the id" do
+          root.selector.should eq({ "_id" => person.id })
+        end
+      end
+
+      context "when using a composite key" do
+
+        let(:account) do
+          Account.new(name: "savings")
+        end
+
+        let(:root) do
+          described_class.new(account)
+        end
+
+        context "when the composite key has changed" do
+
+          before do
+            account.new_record = false
+            account.name = "current"
+          end
+
+          it "returns the hash with the old key" do
+            root.selector.should eq({ "_id" => "savings" })
+          end
+        end
+
+        context "when the composite key has not changed" do
+
+          it "returns the hash with the key" do
+            root.selector.should eq({ "_id" => "savings" })
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/atomic/paths_spec.rb

@@ -0,0 +1,270 @@
+require "spec_helper"
+
+describe Mongoid::Atomic::Paths do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:address) do
+    Address.new(street: "testing")
+  end
+
+  let(:location) do
+    Location.new
+  end
+
+  let(:name) do
+    Name.new
+  end
+
+  describe "#.atomic_delete_modifier" do
+
+    before do
+      person.addresses << address
+      person.name = name
+    end
+
+    context "when document is an embeds_one" do
+
+      it "returns $unset" do
+        name.atomic_delete_modifier.should eq("$unset")
+      end
+    end
+
+    context "when document is an embeds_many" do
+
+      it "returns $pull" do
+        address.atomic_delete_modifier.should eq("$pull")
+      end
+    end
+  end
+
+  describe "#.atomic_insert_modifier" do
+
+    before do
+      person.addresses << address
+      person.name = name
+    end
+
+    context "when document is an embeds_one" do
+
+      it "returns $set" do
+        name.atomic_insert_modifier.should eq("$set")
+      end
+    end
+
+    context "when document is an embeds_many" do
+
+      it "returns $push" do
+        address.atomic_insert_modifier.should eq("$push")
+      end
+    end
+  end
+
+  describe "#.atomic_path" do
+
+    context "when the document is a parent" do
+
+      it "returns an empty string" do
+        person.atomic_path.should be_empty
+      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.atomic_path.should eq("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.atomic_path.should eq("addresses.locations")
+      end
+    end
+  end
+
+  describe "#.atomic_selector" do
+
+    context "when the document is a parent" do
+
+      it "returns an id.atomic_selector" do
+        person.atomic_selector.should eq({ "_id" => person.id })
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      it "returns the association with id.atomic_selector" do
+        address.atomic_selector.should eq(
+          { "_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.atomic_selector.should eq(
+          {
+            "_id" => person.id,
+            "addresses._id" => address.id,
+            "addresses.locations._id" => location.id
+          }
+        )
+      end
+    end
+  end
+
+  describe "#.atomic_position" do
+
+    context "when the document is a parent" do
+
+      it "returns an empty string" do
+        person.atomic_position.should be_empty
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      context "when the document is new" do
+
+        it "returns the.atomic_path without index" do
+          address.atomic_position.should eq("addresses")
+        end
+      end
+
+      context "when the document is not new" do
+
+        before do
+          address.instance_variable_set(:@new_record, false)
+        end
+
+        it "returns the.atomic_path plus index" do
+          address.atomic_position.should eq("addresses.0")
+        end
+      end
+    end
+
+    context "when document embedded multiple levels" do
+
+      let(:other) do
+        Location.new
+      end
+
+      before do
+        address.locations << [ other, location ]
+        address.instance_variable_set(:@new_record, false)
+        person.addresses << address
+      end
+
+      context "when the document is new" do
+
+        it "returns the.atomic_path with parent indexes" do
+          location.atomic_position.should eq("addresses.0.locations")
+        end
+      end
+
+      context "when the document is not new" do
+
+        before do
+          location.instance_variable_set(:@new_record, false)
+        end
+
+        it "returns the.atomic_path plus index" do
+          location.atomic_position.should eq("addresses.0.locations.1")
+        end
+      end
+    end
+  end
+
+  describe "#.atomic_path" do
+
+    context "when the document is a parent" do
+
+      it "returns an empty string" do
+        person.atomic_path.should be_empty
+      end
+    end
+
+    context "when the document is embedded" do
+
+      before do
+        person.addresses << address
+      end
+
+      context "when the document is not new" do
+
+        before do
+          address.instance_variable_set(:@new_record, false)
+        end
+
+        it "returns the.atomic_path without the index" do
+          address.atomic_path.should eq("addresses")
+        end
+
+        context "and there are 10 or more documents" do
+
+          before do
+            10.times do
+              person.addresses << address
+            end
+          end
+
+          it "returns the.atomic_path without the index" do
+            address.atomic_path.should eq("addresses")
+          end
+        end
+      end
+    end
+
+    context "when document embedded multiple levels" do
+
+      let(:other) do
+        Location.new
+      end
+
+      before do
+        address.locations << [ other, location ]
+        address.instance_variable_set(:@new_record, false)
+        person.addresses << address
+      end
+
+      context "when the document is not new" do
+
+        before do
+          location.instance_variable_set(:@new_record, false)
+        end
+
+        it "returns the.atomic_path plus index" do
+          location.atomic_path.should eq("addresses.0.locations")
+        end
+
+      end
+    end
+  end
+end