mongoid 7.1.11 → 7.2.0.rc1

data/spec/mongoid/matchable/lte_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-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
-
-    context "when the value is not numeric" do
-
-      let(:matcher) do
-        described_class.new(5)
-      end
-
-      it "returns false" do
-        expect(matcher._matches?("$lte" => '5.1')).to be false
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/ne_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-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
-
-    context "when the value is an array" do
-
-      let(:array_matcher) do
-        described_class.new([ "first" ])
-      end
-
-      context "when the value is in the array" do
-
-        it "returns false" do
-          expect(array_matcher._matches?("$ne" => "first")).to be false
-        end
-      end
-
-      context "when the value is not in the array" do
-
-        it "returns true" do
-          expect(array_matcher._matches?("$ne" => "second")).to be true
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/nin_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Nin do
-
-  describe "#_matches?" do
-
-    context 'when the attribute is not nil' do
-
-    let(:matcher) do
-      described_class.new("first")
-    end
-
-      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
-
-    context 'when the attribute is nil' do
-      let(:matcher) do
-        described_class.new(nil)
-      end
-
-      context "when the values do not contain the attribute" do
-
-        it "returns true" do
-          expect(matcher._matches?("$nin" => ["third"])).to be true
-        end
-      end
-
-      context "when the values contain the attribute" do
-
-        it "returns false" do
-          expect(matcher._matches?("$nin" => [/\Afir.*\z/, nil])).to be false
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/nor_spec.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Nor do
-
-  let(:target) do
-    Person.new
-  end
-
-  let(:matcher) do
-    described_class.new("value", target)
-  end
-
-  describe "#_matches?" do
-
-    context "when provided a simple expression" do
-
-      context "when one of the hashes does not match model" do
-
-        let(:matches) do
-          matcher._matches?(
-            [ { title: "Sir" }, { title: "King" } ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Queen')
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when all of the hashes match different fields in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { age: 10 }, { title: "King" } ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'King', age: 10)
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when one of the hashes matches an array field in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { af: "Sir" }, { af: "King" } ]
-          )
-        end
-
-        let(:target) do
-          ArrayField.new(af: ['King'])
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when none of the hashes matches an array field in model" do
-        let(:matches) do
-          matcher._matches?(
-            [ { af: "Sir" }, { af: "King" } ]
-          )
-        end
-
-        let(:target) do
-          ArrayField.new(af: ['Boo'])
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when there are no criteria" do
-
-        it "returns false" do
-          expect(matcher._matches?([])).to be false
-        end
-      end
-
-      # $nor with $not is a double negation.
-      # Whatever the argument of $not is is what the overall condition
-      # is looking for.
-      context "when the expression is a $not" do
-
-        let(:matches) do
-          matcher._matches?([ { title: {:$not => /Foobar/ } }])
-        end
-
-        context "when the value does not match $not argument" do
-
-          let(:target) do
-            Person.new(title: 'test')
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-
-        context "when the value matches $not argument" do
-
-          let(:target) do
-            Person.new(title: 'Foobar baz')
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-      end
-    end
-
-    context "when provided a complex expression" do
-
-      context "when none of the model values match criteria values" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Sir", "Madam" ] } },
-              { title: "King" }
-            ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Queen')
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when there is a matching value" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Prince", "Madam" ] } },
-              { title: "King" }
-            ]
-          )
-        end
-
-        let(:target) do
-          Person.new(title: 'Prince')
-        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
-
-        context 'and model has different values in all of the fields' do
-          let(:target) do
-            Person.new(title: 'Queen', age: 10)
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context 'and model has identical value in one of the fields' do
-          let(:target) do
-            Person.new(title: 'Queen', age: 23)
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context 'and model has identical values in all of the fields' do
-          let(:target) do
-            Person.new(title: 'Sir', age: 23)
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/or_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-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
-
-      context "when the expression is a $not" do
-
-        let(:matches) do
-          matcher._matches?([ { title: {:$not => /Foobar/ } }])
-        end
-
-        context "when the value matches" do
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context "when the value does not match" do
-
-          before do
-            person.title = "Foobar baz"
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        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/regexp_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Regexp do
-
-  let(:matcher) do
-    described_class.new(attribute)
-  end
-
-  let(:attribute) do
-    'Emily'
-  end
-
-  describe '#_matches?' do
-
-    context 'when a BSON::Regexp::Raw object is passed' do
-
-      let(:regexp) do
-        BSON::Regexp::Raw.new("\\AEm")
-      end
-
-      it 'compiles the regexp object to a native regexp for the matching' do
-        expect(matcher._matches?(regexp)).to be(true)
-      end
-
-      context 'when the value does not match the attribute' do
-
-        let(:attribute) do
-          'ily'
-        end
-
-        it 'compiles the regexp object to a native regexp for the matching' do
-          expect(matcher._matches?(regexp)).to be(false)
-        end
-      end
-    end
-
-    context 'when a native Regexp object is passed' do
-
-      let(:regexp) do
-        /\AEm/
-      end
-
-      it 'calls super with the native regexp' do
-        expect(matcher._matches?(regexp)).to be(true)
-      end
-
-      context 'when the value does not match the attribute' do
-
-        let(:attribute) do
-          'ily'
-        end
-
-        it 'compiles the regexp object to a native regexp for the matching' do
-          expect(matcher._matches?(regexp)).to be(false)
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/size_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-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