mongoid 7.1.11 → 7.2.0.rc1

data/spec/mongoid/matchable/default_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-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
-        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?(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?(/\ATest[3-5]\z/)).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
-        BSON::ObjectId.new
-      end
-
-      let(:matcher) do
-        described_class.new([ object_id, 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?(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 equals the value" do
-
-        it "returns true" do
-          expect(matcher._matches?(["Test1", "Test2", "Test3"])).to be true
-        end
-      end
-
-      context "when the value contains same items as attribute but in different order" do
-
-        it "returns false" do
-          expect(matcher._matches?(["Test1", "Test3", "Test2"])).to be false
-        end
-      end
-
-      context "when the value is a subset of attribute" do
-
-        it "returns false" do
-          expect(matcher._matches?(["Test1", "Test2"])).to be false
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/elem_match_spec.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::ElemMatch do
-
-  let(:attribute) {[{"a" => 1, "b" => 2}, {"a" => 2, "b" => 2}, {"a" => 3, "b" => 1}]}
-  let(:matcher) do
-    described_class.new(attribute)
-  end
-
-  describe "#_matches?" do
-
-    context "when the attribute is not an array" do
-
-      let(:attribute) {"string"}
-
-      it "returns false" do
-        expect(matcher._matches?("$elemMatch" => {"a" => 1})).to be false
-      end
-    end
-
-    context "when the $elemMatch is not a hash" do
-
-      let(:attribute) {"string"}
-
-      it "returns false" do
-        expect(matcher._matches?("$elemMatch" => [])).to be false
-      end
-    end
-
-    context "when there is a sub document that matches the criteria" do
-
-      it "returns true" do
-        expect(matcher._matches?("$elemMatch" => {"a" => 1})).to be true
-      end
-
-      context "when evaluating multiple fields of the subdocument" do
-
-        it "returns true" do
-          expect(matcher._matches?("$elemMatch" => {"a" => 1, "b" => 2})).to be true
-        end
-
-        context "when the $elemMatch document keys are out of order" do
-
-          it "returns true" do
-            expect(matcher._matches?("$elemMatch" => {"b" => 2, "a" => 1})).to be true
-          end
-        end
-      end
-
-      context "when using other operators that match" do
-
-        it "returns true" do
-          expect(matcher._matches?("$elemMatch" => {"a" => {"$in" => [1]}, "b" => {"$gt" => 1}})).to be true
-        end
-      end
-
-      context "when using a $not operator that matches" do
-
-        it "returns true" do
-          expect(matcher._matches?("$elemMatch" => {"a" => {"$not" => 4}})).to be true
-        end
-      end
-    end
-
-    context "when using symbols and a :$not operator that matches" do
-      it "returns true" do
-        expect(matcher._matches?(:$elemMatch => {"a" => {:$not => 4}})).to be true
-      end
-    end
-
-    context "when there is not a sub document that matches the criteria" do
-
-      it "returns false" do
-        expect(matcher._matches?("$elemMatch" => {"a" => 10})).to be false
-      end
-
-      context "when evaluating multiple fields of the subdocument" do
-
-        it "returns false" do
-          expect(matcher._matches?("$elemMatch" => {"a" => 1, "b" => 3})).to be false
-        end
-      end
-
-      context "when using other operators that do not match" do
-
-        it "returns true" do
-          expect(matcher._matches?("$elemMatch" => {"a" => {"$in" => [1]}, "b" => {"$gt" => 10}})).to be false
-        end
-      end
-
-      context "when using a $not operator that does not match" do
-
-        it "returns true" do
-          expect(matcher._matches?("$elemMatch" => {"a" => {"$not" => 1}})).to be true
-        end
-      end
-    end
-
-    context "when using a criteria that matches partially but not a single sub document" do
-
-      it "returns false" do
-        expect(matcher._matches?("$elemMatch" => {"a" => 3, "b" => 2})).to be false
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/eq_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Eq do
-
-  let(:matcher) do
-    described_class.new("first")
-  end
-
-  describe "#_matches?" do
-
-    context "when the values are equal" do
-
-      it "returns true" do
-        expect(matcher._matches?("$eq" => "first")).to be true
-      end
-    end
-
-    context "when the values are not equal" do
-
-      it "returns false" do
-        expect(matcher._matches?("$eq" => "second")).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 true" do
-          expect(array_matcher._matches?("$eq" => "first")).to be true
-        end
-      end
-
-      context "when the value is not in the array" do
-
-        it "returns false" do
-          expect(array_matcher._matches?("$eq" => "second")).to be false
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/exists_spec.rb

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

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

data/spec/mongoid/matchable/gte_spec.rb

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

data/spec/mongoid/matchable/in_spec.rb

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

data/spec/mongoid/matchable/lt_spec.rb

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