mongoid_rails4 4.0.0

data/spec/mongoid/unit_of_work_spec.rb

@@ -0,0 +1,196 @@
+require "spec_helper"
+
+describe Mongoid::UnitOfWork do
+
+  describe ".unit_of_work" do
+
+    before do
+      Mongoid.identity_map_enabled = true
+    end
+
+    after do
+      Mongoid.identity_map_enabled = false
+    end
+
+    context "when no options are provided" do
+
+      context "when an exception is raised" do
+
+        let(:person) do
+          Person.new
+        end
+
+        before do
+          Mongoid::IdentityMap.set(person)
+
+          begin
+            Mongoid.unit_of_work do
+              raise RuntimeError
+            end
+          rescue
+          end
+        end
+
+        let(:identity_map) do
+          Mongoid::Threaded.identity_map
+        end
+
+        it "clears the identity map" do
+          expect(identity_map).to be_empty
+        end
+      end
+
+      context "when no exception is raised" do
+
+        let(:person) do
+          Person.new
+        end
+
+        before do
+          Mongoid::IdentityMap.set(person)
+          Mongoid.unit_of_work {}
+        end
+
+        let(:identity_map) do
+          Mongoid::Threaded.identity_map
+        end
+
+        it "clears the identity map" do
+          expect(identity_map).to be_empty
+        end
+      end
+    end
+  end
+
+  context "when options are provided" do
+
+    before do
+      Mongoid.identity_map_enabled = true
+    end
+
+    after do
+      Mongoid.identity_map_enabled = false
+    end
+
+    context "when provided disable: :current" do
+
+      it "disables the identity map on the current thread" do
+        Mongoid.unit_of_work(disable: :current) do
+          expect(Mongoid).to_not be_using_identity_map
+        end
+      end
+    end
+
+    context "when provided disable: :all" do
+
+      let(:other) do
+        Thread.new { "running new thread".inspect }
+      end
+
+      before do
+        other.run
+        Thread.current
+      end
+
+      after do
+        Thread.kill(other)
+      end
+
+      it "disables the identity map on all threads" do
+        Mongoid.unit_of_work(disable: :all) do
+          Thread.list.each do |thread|
+            expect(thread[:"[mongoid]:identity-map-enabled"]).to be_false
+          end
+        end
+      end
+    end
+
+    context "when nested inside another unit of work" do
+
+      let(:person) do
+        Person.new
+      end
+
+      context "when documents exist in the identity map" do
+
+        before do
+          Mongoid::IdentityMap.set(person)
+        end
+
+        it "does not clear the map in the inner block" do
+          Mongoid.unit_of_work do
+            Mongoid.unit_of_work(disable: :current) do
+              expect(Mongoid::IdentityMap[:people][person.id]).to eq(person)
+            end
+          end
+        end
+
+        it "clears the map after the block" do
+          Mongoid.unit_of_work do
+            Mongoid.unit_of_work(disable: :current) do
+            end
+          end
+          expect(Mongoid::IdentityMap.get(Person, person.id)).to be_nil
+        end
+      end
+    end
+  end
+
+  describe ".using_identity_map?" do
+
+    context "when configured to use the identity map" do
+
+      before do
+        Mongoid.identity_map_enabled = true
+      end
+
+      after do
+        Mongoid.identity_map_enabled = false
+      end
+
+      context "when disabled on the current thread" do
+
+        before do
+          Thread.current[:"[mongoid]:identity-map-enabled"] = false
+        end
+
+        it "returns false" do
+          expect(Mongoid).to_not be_using_identity_map
+        end
+      end
+
+      context "when enabled on the current thread" do
+
+        before do
+          Thread.current[:"[mongoid]:identity-map-enabled"] = true
+        end
+
+        it "returns true" do
+          expect(Mongoid).to be_using_identity_map
+        end
+      end
+
+      context "when no option is on the current thread" do
+
+        before do
+          Thread.current[:"[mongoid]:identity-map-enabled"] = nil
+        end
+
+        it "returns true" do
+          expect(Mongoid).to be_using_identity_map
+        end
+      end
+    end
+
+    context "when not configured to use the identity map" do
+
+      before do
+        Mongoid.identity_map_enabled = false
+      end
+
+      it "returns false" do
+        expect(Mongoid).to_not be_using_identity_map
+      end
+    end
+  end
+end

data/spec/mongoid/validatable/associated_spec.rb

@@ -0,0 +1,183 @@
+require "spec_helper"
+
+describe Mongoid::Validatable::AssociatedValidator do
+
+  describe "#valid?" do
+
+    context "when validating associated on both sides" do
+
+      context "when the documents are valid" do
+
+        let(:user) do
+          User.new(name: "test")
+        end
+
+        let(:description) do
+          Description.new(details: "testing")
+        end
+
+        before do
+          user.descriptions << description
+        end
+
+        it "only validates the parent once" do
+          expect(user).to be_valid
+        end
+
+        it "only validates the child once" do
+          expect(description).to be_valid
+        end
+      end
+
+      context "when the documents are not valid" do
+
+        let(:user) do
+          User.new(name: "test")
+        end
+
+        let(:description) do
+          Description.new
+        end
+
+        before do
+          user.descriptions << description
+        end
+
+        it "only validates the parent once" do
+          expect(user).to_not be_valid
+        end
+
+        it "adds the errors from the relation" do
+          user.valid?
+          expect(user.errors[:descriptions]).to_not be_nil
+        end
+
+        it "only validates the child once" do
+          expect(description).to_not be_valid
+        end
+      end
+    end
+  end
+
+  describe "#validate_each" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let(:validator) do
+      described_class.new(attributes: person.attributes)
+    end
+
+    context "when the association is a one to one" do
+
+      context "when the association is nil" do
+
+        before do
+          validator.validate_each(person, :name, nil)
+        end
+
+        it "adds no errors" do
+          expect(person.errors[:name]).to be_empty
+        end
+      end
+
+      context "when the association is valid" do
+
+        let(:associated) do
+          double(valid?: true)
+        end
+
+        before do
+          associated.should_receive(:validated?).and_return(false)
+          validator.validate_each(person, :name, associated)
+        end
+
+        it "adds no errors" do
+          expect(person.errors[:name]).to be_empty
+        end
+      end
+
+      context "when the association is invalid" do
+
+        let(:associated) do
+          double(valid?: false)
+        end
+
+        before do
+          associated.should_receive(:validated?).and_return(false)
+          validator.validate_each(person, :name, associated)
+        end
+
+        it "adds errors to the parent document" do
+          expect(person.errors[:name]).to_not be_empty
+        end
+
+        it "translates the error in english" do
+          expect(person.errors[:name][0]).to eq("is invalid")
+        end
+      end
+    end
+
+    context "when the association is a one to many" do
+
+      context "when the association is empty" do
+
+        before do
+          validator.validate_each(person, :addresses, [])
+        end
+
+        it "adds no errors" do
+          expect(person.errors[:addresses]).to be_empty
+        end
+      end
+
+      context "when the association has invalid documents" do
+
+        let(:associated) do
+          double(valid?: false)
+        end
+
+        before do
+          associated.should_receive(:validated?).and_return(false)
+          validator.validate_each(person, :addresses, [ associated ])
+        end
+
+        it "adds errors to the parent document" do
+          expect(person.errors[:addresses]).to_not be_empty
+        end
+      end
+
+      context "when the assocation has all valid documents" do
+
+        let(:associated) do
+          double(valid?: true)
+        end
+
+        before do
+          associated.should_receive(:validated?).and_return(false)
+          validator.validate_each(person, :addresses, [ associated ])
+        end
+
+        it "adds no errors" do
+          expect(person.errors[:addresses]).to be_empty
+        end
+      end
+    end
+  end
+
+  context "when describing validation on the instance level" do
+
+    let!(:dictionary) do
+      Dictionary.create!(name: "en")
+    end
+
+    let(:validators) do
+      dictionary.validates_associated :words
+    end
+
+    it "adds the validation only to the instance" do
+      expect(validators).to eq([ described_class ])
+    end
+  end
+end

data/spec/mongoid/validatable/format_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe Mongoid::Validatable::FormatValidator do
+
+  describe "#validate_each" do
+
+    let(:product) do
+      Product.new
+    end
+
+    context "when the field is not localized" do
+
+      let(:validator) do
+        described_class.new(attributes: [:brand_name], with: /\A[a-z]*\z/i)
+      end
+
+      context "when the value is valid" do
+
+        before do
+          validator.validate_each(product, :brand_name, "Apple")
+        end
+
+        it "adds no errors" do
+          expect(product.errors[:brand_name]).to be_empty
+        end
+      end
+
+      context "when the value is invalid" do
+
+        before do
+          validator.validate_each(product, :brand_name, "123")
+        end
+
+        it "adds errors" do
+          expect(product.errors[:brand_name]).to eq(["is invalid"])
+        end
+      end
+    end
+
+    context "when the field is localized" do
+
+      let(:validator) do
+        described_class.new(attributes: [:website], with: URI.regexp)
+      end
+
+      context "when the localized value is valid" do
+
+        before do
+          validator.validate_each(product, :website, { "en" => "http://www.apple.com" })
+        end
+
+        it "adds no errors" do
+          expect(product.errors[:website]).to be_empty
+        end
+      end
+
+      context "when one of the localized values is invalid" do
+
+        before do
+          validator.validate_each(
+            product,
+            :website, { "en" => "http://www.apple.com", "fr" => "not_a_website" }
+          )
+        end
+
+        it "adds errors" do
+          expect(product.errors[:website]).to eq(["is invalid"])
+        end
+      end
+
+      context "when the localized value is invalid" do
+
+        before do
+          validator.validate_each(product, :website, { "en" => "not_a_website" })
+        end
+
+        it "adds errors" do
+          expect(product.errors[:website]).to eq(["is invalid"])
+        end
+      end
+    end
+  end
+end