mongoid_rails4 4.0.0

data/spec/mongoid/matchable/gte_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Gte 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?("$gte" => 3)).to be_true
+      end
+    end
+
+    context "when the value is smaller" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gte" => 10)).to be_false
+      end
+    end
+
+    context "when the value is equal" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns true" do
+        expect(matcher.matches?("$gte" => 5)).to be_true
+      end
+    end
+
+    context "when the value is nil" do
+
+      let(:matcher) do
+        described_class.new(nil)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gte" => 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?("$gte" => 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?("$gte" => 5)).to be_false
+        end
+
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/in_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::In do
+
+  let(:matcher) do
+    described_class.new("first")
+  end
+
+  describe "#matches?" do
+
+    context "when the values include the attribute" do
+
+      it "returns true" do
+        expect(matcher.matches?("$in" => [/\Afir.*\z/, "second"])).to be_true
+      end
+    end
+
+    context "when the values don't include the attribute" do
+
+      it "returns false" do
+        expect(matcher.matches?("$in" => ["third"])).to be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/lt_spec.rb

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

data/spec/mongoid/matchable/lte_spec.rb

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

data/spec/mongoid/matchable/ne_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Ne do
+
+  let(:matcher) do
+    described_class.new("first")
+  end
+
+  describe "#matches?" do
+
+    context "when the values are not equal" do
+
+      it "returns true" do
+        expect(matcher.matches?("$ne" => "second")).to be_true
+      end
+    end
+
+    context "when the values are equal" do
+
+      it "returns false" do
+        expect(matcher.matches?("$ne" => "first")).to be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/nin_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Nin do
+
+  let(:matcher) do
+    described_class.new("first")
+  end
+
+  describe "#matches?" do
+
+    context "when the values do not contain the attribute" do
+
+      it "returns true" do
+        expect(matcher.matches?("$nin" => ["second", "third"])).to be_true
+      end
+    end
+
+    context "when the values contain the attribute" do
+
+      it "returns false" do
+        expect(matcher.matches?("$nin" => ["first"])).to be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/or_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Or 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 any of the values are equal" do
+
+        let(:matches) do
+          matcher.matches?(
+            [ { title: "Sir" }, { title: "King" } ]
+          )
+        end
+
+        before do
+          person.title = "Sir"
+        end
+
+        it "returns true" do
+          expect(matches).to be_true
+        end
+      end
+
+      context "when none of the values are equal" do
+
+        it "returns false" do
+          expect(matcher.matches?([])).to be_false
+        end
+      end
+    end
+
+    context "when provided a complex expression" do
+
+      context "when any of the values are equal" do
+
+        let(:matches) do
+          matcher.matches?(
+            [
+              { title: { "$in" => [ "Sir", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        end
+
+        before do
+          person.title = "Sir"
+        end
+
+        it "returns true" do
+          expect(matches).to be_true
+        end
+      end
+
+      context "when none of the values are equal" do
+
+        let(:matches) do
+          matcher.matches?(
+            [
+              { title: { "$in" => [ "Prince", "Madam" ] } },
+              { title: "King" }
+            ]
+          )
+        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
+
+        let(:matches) do
+          matcher.matches?(
+            [
+              { title: "Sir", age: 23 },
+              { title: "King", age: 100 }
+            ]
+          )
+        end
+
+        before do
+          person.title = "Sir"
+          person.age = 100
+        end
+
+        it "returns false" do
+          expect(matches).to be_false
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/matchable/size_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Mongoid::Matchable::Size do
+
+  let(:matcher) do
+    described_class.new(["first", "second"])
+  end
+
+  describe "#matches?" do
+
+    context "when the attribute is the same size" do
+
+      it "returns true" do
+        expect(matcher.matches?("$size" => 2)).to be_true
+      end
+    end
+
+    context "when the attribute is not the same size" do
+
+      it "returns false" do
+        expect(matcher.matches?("$size" => 5)).to be_false
+      end
+    end
+  end
+end

data/spec/mongoid/matchable_spec.rb

@@ -0,0 +1,532 @@
+require "spec_helper"
+
+describe Mongoid::Matchable do
+
+  describe "#matches?" do
+
+    context "when document is embeded" do
+
+      let(:document) do
+        Address.new(street: "Clarkenwell Road")
+      end
+
+      before do
+        document.locations << Location.new(
+          name: 'No.1',
+          info: { 'door' => 'Red'},
+          occupants: [{'name' => 'Tim'}]
+        )
+      end
+
+      context "when the attributes do not match" do
+
+        let(:selector) do
+          { name: { "$in" => ["No.2"], "$ne" => nil } }
+        end
+
+        it "returns false" do
+          expect(document.locations.first.matches?(selector)).to be_false
+        end
+
+        context "when just change the selector order" do
+
+          let(:selector) do
+            { name: { "$ne" => nil, "$in" => ["No.2"] } }
+          end
+
+          it "returns false " do
+            expect(document.locations.first.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "when matching embedded hash values" do
+
+        context "when the contents match" do
+
+          let(:selector) do
+            { "info.door" => "Red" }
+          end
+
+          it "returns true" do
+            expect(document.locations.first.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the contents do not match" do
+
+          let(:selector) do
+            { "info.door" => "Blue" }
+          end
+
+          it "returns false" do
+            expect(document.locations.first.matches?(selector)).to be_false
+          end
+        end
+
+        context "when the contents do not exist" do
+
+          let(:selector) do
+            { "info.something_else" => "Red" }
+          end
+
+          it "returns false" do
+            expect(document.locations.first.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "when matching values of multiple embedded hashes" do
+
+        context "when the contents match" do
+
+          let(:selector) do
+            { "occupants.name" => "Tim" }
+          end
+
+          it "returns true" do
+            expect(document.locations.first.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the contents do not match" do
+
+          let(:selector) do
+            { "occupants.name" => "Lyle" }
+          end
+
+          it "returns false" do
+            expect(document.locations.first.matches?(selector)).to be_false
+          end
+        end
+
+        context "when the contents do not exist" do
+
+          let(:selector) do
+            { "occupants.something_else" => "Tim" }
+          end
+
+          it "returns false" do
+            expect(document.locations.first.matches?(selector)).to be_false
+          end
+        end
+      end
+
+    end
+
+    context "when performing simple matching" do
+
+      let(:document) do
+        Address.new(street: "Clarkenwell Road")
+      end
+
+      context "when the attributes match" do
+
+        let(:selector) do
+          { street: "Clarkenwell Road" }
+        end
+
+        it "returns true" do
+          expect(document.matches?(selector)).to be_true
+        end
+      end
+
+      context "when the attributes dont match" do
+
+        let(:selector) do
+          { street: "Broadway Ave" }
+        end
+
+        it "returns false" do
+          expect(document.matches?(selector)).to be_false
+        end
+      end
+    end
+
+    context "when performing complex matching" do
+
+      let(:document) do
+        Address.new(
+          services: ["first", "second", "third"],
+          number: 100,
+          map: { key: "value" }
+        )
+      end
+
+      context "with an $all selector" do
+
+        context "when the attribute includes all of the values" do
+
+          let(:selector) do
+            { services: { "$all" => [ "first", "second" ] } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes doesn't include all of the values" do
+
+          let(:selector) do
+            { services: { "$all" => [ "second", "third", "fourth" ] } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with an $exists selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { services: { "$exists" => true } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { services: { "$exists" => false } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $gt selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$gt" => 50 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$gt" => 200 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $gt selector as a symbol" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { :$gt => 50 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { :$gt => 200 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $gte selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$gte" => 100 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$gte" => 200 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with an $in selector on Array" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { services: { "$in" => [ /\Afir.*\z/, "second" ] } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$in" => [ "none" ] } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with an $in selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$in" => [ 100, 200 ] } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$in" => [ 200, 300 ] } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $lt selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$lt" => 200 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$lt" => 50 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $lte selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$lte" => 200 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$lte" => 50 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with an $ne selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$ne" => 200 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$ne" => 100 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $nin selector on Array" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { services: { "$nin" => [ "none" ] } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { services: { "$nin" => [ "first" ] } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $nin selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { number: { "$nin" => [ 1, 2, 3 ] } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { number: { "$nin" => [ 100 ] } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with an $or selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { "$or" => [ { number: 10 }, { number: { "$gt" => 99 } } ] }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { "$or" => [ { number: 10 }, { number: { "$lt" => 99 } } ] }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a $size selector" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { services: { "$size" => 3 } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { services: { "$size" => 5 } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+
+      context "with a hash value" do
+
+        context "when the attributes match" do
+
+          let(:selector) do
+            { map: { key: "value" } }
+          end
+
+          it "returns true" do
+            expect(document.matches?(selector)).to be_true
+          end
+        end
+
+        context "when the attributes do not match" do
+
+          let(:selector) do
+            { map: { key: "value2" } }
+          end
+
+          it "returns false" do
+            expect(document.matches?(selector)).to be_false
+          end
+        end
+      end
+    end
+  end
+end