mongoid 3.1.4 → 3.1.5

data/spec/mongoid/json_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Mongoid::JSON do
+
+  describe ".include_root_in_json" do
+
+    let(:person) do
+      Person.new
+    end
+
+    context "when config set to true" do
+
+      before do
+        Mongoid.include_root_in_json = true
+      end
+
+      it "returns true" do
+        person.include_root_in_json.should be_true
+      end
+    end
+
+    context "when config set to false" do
+
+      before do
+        Mongoid.include_root_in_json = false
+      end
+
+      it "returns false" do
+        person.include_root_in_json.should be_false
+      end
+    end
+  end
+end

data/spec/mongoid/loggable_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Mongoid::Loggable do
+
+  describe "#logger=" do
+
+    let(:logger) do
+      Logger.new($stdout).tap do |log|
+        log.level = Logger::INFO
+      end
+    end
+
+    before do
+      Mongoid.logger = logger
+    end
+
+    it "sets the logger" do
+      Mongoid.logger.should eq(logger)
+    end
+  end
+end

data/spec/mongoid/matchers/all_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::All do
+
+  let(:matcher) do
+    described_class.new(["first", "second", "third"])
+  end
+
+  describe "#matches?" do
+
+    context "when the attribute includes all of the values" do
+
+      it "returns true" do
+        matcher.matches?("$all" => ["first", /\Asec.*\z/]).should be_true
+      end
+    end
+
+    context "when the attributes doesn't include all of the values" do
+
+      it "returns false" do
+        matcher.matches?("$all" => ["second", "third", "fourth"]).should be_false
+      end
+    end
+
+    context "when the value is empty" do
+      it "returns false" do
+        matcher.matches?("$all" => []).should be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchers/and_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::And do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:matcher) do
+    described_class.new("value", person)
+  end
+
+  describe "#matches?" do
+
+    context "when provided a simple expression" do
+
+      context "when only one expression provided" do
+
+        context "when the value matches" do
+
+          let(:matches) do
+            matcher.matches?([ { title: "Sir" } ])
+          end
+
+          before do
+            person.title = "Sir"
+          end
+
+          it "returns true" do
+            matches.should be_true
+          end
+        end
+
+        context "when the value does not match" do
+
+          let(:matches) do
+            matcher.matches?([ { title: "Sir" } ])
+          end
+
+          it "returns false" do
+            matches.should be_false
+          end
+        end
+      end
+
+      context "when multiple expressions provided" do
+
+        context "when all of the values are equal" do
+
+          let(:matches) do
+            matcher.matches?(
+              [ { title: "Sir" }, { _id: person.id } ]
+            )
+          end
+
+          before do
+            person.title = "Sir"
+          end
+
+          it "returns true" do
+            matches.should be_true
+          end
+        end
+
+        context "when one of the values does not match" do
+
+          let(:matches) do
+            matcher.matches?(
+              [ { title: "Sir" }, { _id: Moped::BSON::ObjectId.new } ]
+            )
+          end
+
+          before do
+            person.title = "Sir"
+          end
+
+          it "returns false" do
+            matches.should be_false
+          end
+        end
+
+        context "when provided no expressions" do
+
+          let(:matches) do
+            matcher.matches?([])
+          end
+
+          it "returns true" do
+            matches.should be_true
+          end
+        end
+      end
+    end
+
+    context "when provided a complex expression" do
+
+      context "when all of the values are equal" do
+
+        let(:matches) do
+          matcher.matches?(
+            [
+              { title: { "$in" => [ "Sir", "Madam" ] } },
+              { _id: person.id }
+            ]
+          )
+        end
+
+        before do
+          person.title = "Sir"
+        end
+
+        it "returns true" do
+          matches.should be_true
+        end
+      end
+
+      context "when one of the values does not match" do
+
+        let(:matches) do
+          matcher.matches?(
+            [
+              { title: { "$in" => [ "Prince", "Madam" ] } },
+              { _id: Moped::BSON::ObjectId.new }
+            ]
+          )
+        end
+
+        before do
+          person.title = "Sir"
+        end
+
+        it "returns false" do
+          matches.should be_false
+        end
+      end
+
+      context "when expression contain multiple fields" do
+
+        context "when all the expressions match" do
+
+          let(:matches) do
+            matcher.matches?(
+              [
+                { title: "Sir", age: 23 },
+                { _id: person.id }
+              ]
+            )
+          end
+
+          before do
+            person.title = "Sir"
+            person.age = 23
+          end
+
+          it "returns true" do
+            matches.should be_true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchers/default_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::Default do
+
+  describe "#matches?" do
+
+    context "when comparing strings" do
+
+      let(:matcher) do
+        described_class.new("Testing")
+      end
+
+      context "when the values are equal" do
+
+        it "returns true" do
+          matcher.matches?("Testing").should be_true
+        end
+      end
+
+      context "when the values are not equal" do
+
+        it "returns false" do
+          matcher.matches?("Other").should be_false
+        end
+      end
+    end
+
+    context "when comparing object ids" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:matcher) do
+        described_class.new(object_id)
+      end
+
+      context "when the values are equal" do
+
+        it "returns true" do
+          matcher.matches?(object_id).should be_true
+        end
+      end
+
+      context "when the values are not equal" do
+
+        it "returns false" do
+          matcher.matches?(Moped::BSON::ObjectId.new).should be_false
+        end
+      end
+    end
+
+    context "when comparing a string to an array" do
+
+      let(:matcher) do
+        described_class.new(["Test1", "Test2", "Test3"])
+      end
+
+      context "when the attribute contains the value" do
+
+        context "when the value is a string" do
+
+          it "returns true" do
+            matcher.matches?("Test1").should be_true
+          end
+        end
+
+        context "when the value is a regexp" do
+
+          it "returns true" do
+            matcher.matches?(/^Test[3-5]$/).should be_true
+          end
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          matcher.matches?("Test4").should be_false
+        end
+      end
+    end
+
+    context "when comparing an object id to an array" do
+
+      let(:object_id) do
+        Moped::BSON::ObjectId.new
+      end
+
+      let(:matcher) do
+        described_class.new([ object_id, Moped::BSON::ObjectId.new ])
+      end
+
+      context "when the attribute contains the value" do
+
+        it "returns true" do
+          matcher.matches?(object_id).should be_true
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          matcher.matches?(Moped::BSON::ObjectId.new).should be_false
+        end
+      end
+    end
+
+    context "when comparing an array to an array" do
+
+      let(:matcher) do
+        described_class.new(["Test1", "Test2", "Test3"])
+      end
+
+      context "when the attribute contains the value" do
+
+        it "returns true" do
+          matcher.matches?(["Test1", "Test2", "Test3"]).should be_true
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          matcher.matches?(["Test1", "Test2"]).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchers/exists_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::Exists do
+
+  describe "#matches?" do
+
+    context "when checking for existence" do
+
+      context "when the value exists" do
+
+        let(:matcher) do
+          described_class.new("Test")
+        end
+
+        it "returns true" do
+          matcher.matches?("$exists" => true).should be_true
+        end
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) do
+          described_class.new(nil)
+        end
+
+        it "returns false" do
+          matcher.matches?("$exists" => true).should be_false
+        end
+      end
+    end
+
+    context "when checking for nonexistence" do
+
+      context "when the value exists" do
+
+        let(:matcher) do
+          described_class.new("Test")
+        end
+
+        it "returns false" do
+          matcher.matches?("$exists" => false).should be_false
+        end
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) do
+          described_class.new(nil)
+        end
+
+        it "returns true" do
+          matcher.matches?("$exists" => false).should be_true
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchers/gt_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Mongoid::Matchers::Gt do
+
+  describe "#matches?" do
+
+    context "when the value is larger" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns true" do
+        matcher.matches?("$gt" => 3).should be_true
+      end
+    end
+
+    context "when the value is equal" do
+
+      let(:matcher) do
+        described_class.new(3)
+      end
+
+      it "returns false" do
+        matcher.matches?("$gt" => 3).should be_false
+      end
+    end
+
+    context "when the value is smaller" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        matcher.matches?("$gt" => 10).should be_false
+      end
+    end
+
+    context "when the value is nil" do
+
+      let(:matcher) do
+        described_class.new(nil)
+      end
+
+      it "returns false" do
+        matcher.matches?("$gt" => 5).should be_false
+      end
+    end
+
+    context "when the value is an array" do
+      context "there are value valid" do
+        let(:matcher) do
+          described_class.new([6,4])
+        end
+
+        it "returns false" do
+          matcher.matches?("$gt" => 5).should be_true
+        end
+      end
+
+      context "there are not value valid" do
+        let(:matcher) do
+          described_class.new([3,4])
+        end
+
+        it "returns false" do
+          matcher.matches?("$gt" => 5).should be_false
+        end
+
+      end
+    end
+  end
+end