mongoid_rails4 4.0.0

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
+      expect(Mongoid.logger).to eq(logger)
+    end
+  end
+end

data/spec/mongoid/matchable/all_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::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
+        expect(matcher.matches?("$all" => ["first", /\Asec.*\z/])).to be_true
+      end
+    end
+
+    context "when the attributes doesn't include all of the values" do
+
+      it "returns false" do
+        expect(matcher.matches?("$all" => ["second", "third", "fourth"])).to be_false
+      end
+    end
+
+    context "when the value is empty" do
+      it "returns false" do
+        expect(matcher.matches?("$all" => [])).to be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/and_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::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
+            expect(matches).to be_true
+          end
+        end
+
+        context "when the value does not match" do
+
+          let(:matches) do
+            matcher.matches?([ { title: "Sir" } ])
+          end
+
+          it "returns false" do
+            expect(matches).to 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
+            expect(matches).to 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
+            expect(matches).to be_false
+          end
+        end
+
+        context "when provided no expressions" do
+
+          let(:matches) do
+            matcher.matches?([])
+          end
+
+          it "returns true" do
+            expect(matches).to 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
+          expect(matches).to 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
+          expect(matches).to 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
+            expect(matches).to be_true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/default_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::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
+          expect(matcher.matches?("Testing")).to be_true
+        end
+      end
+
+      context "when the values are not equal" do
+
+        it "returns false" do
+          expect(matcher.matches?("Other")).to 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
+          expect(matcher.matches?(object_id)).to be_true
+        end
+      end
+
+      context "when the values are not equal" do
+
+        it "returns false" do
+          expect(matcher.matches?(Moped::BSON::ObjectId.new)).to 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
+            expect(matcher.matches?("Test1")).to be_true
+          end
+        end
+
+        context "when the value is a regexp" do
+
+          it "returns true" do
+            expect(matcher.matches?(/^Test[3-5]$/)).to be_true
+          end
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          expect(matcher.matches?("Test4")).to 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
+          expect(matcher.matches?(object_id)).to be_true
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          expect(matcher.matches?(Moped::BSON::ObjectId.new)).to 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
+          expect(matcher.matches?(["Test1", "Test2", "Test3"])).to be_true
+        end
+      end
+
+      context "when the attribute does not contain the value" do
+
+        it "returns false" do
+          expect(matcher.matches?(["Test1", "Test2"])).to be_false
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/exists_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::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
+          expect(matcher.matches?("$exists" => true)).to be_true
+        end
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) do
+          described_class.new(nil)
+        end
+
+        it "returns false" do
+          expect(matcher.matches?("$exists" => true)).to 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
+          expect(matcher.matches?("$exists" => false)).to be_false
+        end
+      end
+
+      context "when the value does not exist" do
+
+        let(:matcher) do
+          described_class.new(nil)
+        end
+
+        it "returns true" do
+          expect(matcher.matches?("$exists" => false)).to be_true
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/gt_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Gt do
+
+  describe "#matches?" do
+
+    context "when the value is larger" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns true" do
+        expect(matcher.matches?("$gt" => 3)).to be_true
+      end
+    end
+
+    context "when the value is equal" do
+
+      let(:matcher) do
+        described_class.new(3)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gt" => 3)).to be_false
+      end
+    end
+
+    context "when the value is smaller" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gt" => 10)).to be_false
+      end
+    end
+
+    context "when the value is nil" do
+
+      let(:matcher) do
+        described_class.new(nil)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gt" => 5)).to 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
+          expect(matcher.matches?("$gt" => 5)).to be_true
+        end
+      end
+
+      context "there are not value valid" do
+
+        let(:matcher) do
+          described_class.new([3,4])
+        end
+
+        it "returns false" do
+          expect(matcher.matches?("$gt" => 5)).to be_false
+        end
+      end
+    end
+  end
+end