mongoid 7.0.13 → 8.0.8

data/spec/app/models/actress.rb

@@ -1,2 +0,0 @@
-class Actress < Actor
-end

data/spec/app/models/augmentation.rb

@@ -1,11 +0,0 @@
-class Augmentation
-  include Mongoid::Document
-
-  field :name
-
-  embedded_in :player, inverse_of: :augmentation
-
-  after_build do
-    self.name = "Infolink (#{player.frags})"
-  end
-end

data/spec/app/models/bed.rb

@@ -1 +0,0 @@
-class Bed; end

data/spec/app/models/car.rb

@@ -1 +0,0 @@
-class Car < Vehicle; end

data/spec/app/models/circus.rb

@@ -1,7 +0,0 @@
-class Circus
-  include Mongoid::Document
-
-  field :name
-
-  embeds_many :animals
-end

data/spec/app/models/eraser.rb

@@ -1 +0,0 @@
-class Eraser < Tool; end

data/spec/app/models/learner.rb

@@ -1,2 +0,0 @@
-class Learner < Driver
-end

data/spec/app/models/my_hash.rb

@@ -1,2 +0,0 @@
-class MyHash < ::Hash
-end

data/spec/app/models/other_owner_object.rb

@@ -1,2 +0,0 @@
-class OtherOwnerObject
-end

data/spec/app/models/passport.rb

@@ -1,5 +0,0 @@
-class Passport
-  include Mongoid::Document
-  field :number, type: String
-  embedded_in :person, autobuild: true
-end

data/spec/app/models/pencil.rb

@@ -1 +0,0 @@
-class Pencil < Tool; end

data/spec/app/models/powerup.rb

@@ -1,11 +0,0 @@
-class Powerup
-  include Mongoid::Document
-
-  field :name
-
-  belongs_to :player, inverse_of: :powerup
-
-  after_build do
-    self.name = "Quad Damage (#{player.frags})"
-  end
-end

data/spec/app/models/profile.rb

@@ -1,5 +0,0 @@
-class Profile
-  include Mongoid::Document
-  field :name, type: String
-  shard_key :name
-end

data/spec/app/models/series.rb

@@ -1,4 +0,0 @@
-class Series
-  include Mongoid::Document
-  has_many :books
-end

data/spec/app/models/truck.rb

@@ -1,3 +0,0 @@
-class Truck < Vehicle
-  embeds_one :bed
-end

data/spec/app/models/vehicle.rb

@@ -1,11 +0,0 @@
-class Vehicle
-  include Mongoid::Document
-  belongs_to :shipping_container
-  belongs_to :driver
-
-  accepts_nested_attributes_for :driver
-  accepts_nested_attributes_for :shipping_container
-end
-
-require "app/models/car"
-require "app/models/truck"

data/spec/app/models/video_game.rb

@@ -1 +0,0 @@
-class VideoGame < Game; end

data/spec/app/models/weapon.rb

@@ -1,11 +0,0 @@
-class Weapon
-  include Mongoid::Document
-
-  field :name
-
-  belongs_to :player, inverse_of: :weapons
-
-  after_build do
-    self.name = "Holy Hand Grenade (#{player.frags})"
-  end
-end

data/spec/mongoid/criteria/queryable/forwardable_spec.rb

@@ -1,87 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Criteria::Queryable::Forwardable do
-
-  describe ".select_with" do
-
-    context "when extending from a class" do
-
-      before(:all) do
-        class Mountain
-          extend Mongoid::Criteria::Queryable::Forwardable
-          select_with :queryable
-
-          def self.queryable
-            Query.new
-          end
-        end
-      end
-
-      after(:all) do
-        Object.send(:remove_const, :Mountain)
-      end
-
-      context "when provided a symbol" do
-
-        Mongoid::Criteria::Queryable::Selectable.forwardables.each do |method|
-
-          it "forwards #{method} to the provided method name" do
-            expect(Mountain).to respond_to(method)
-          end
-        end
-
-        Mongoid::Criteria::Queryable::Optional.forwardables.each do |method|
-
-          it "forwards #{method} to the provided method name" do
-            expect(Mountain).to respond_to(method)
-          end
-        end
-      end
-    end
-
-    context "when extending from a module" do
-
-      before(:all) do
-        module Finders
-          extend Mongoid::Criteria::Queryable::Forwardable
-          select_with :queryable
-
-          def self.queryable
-            Query.new
-          end
-        end
-      end
-
-      after(:all) do
-        Object.send(:remove_const, :Finders)
-      end
-
-      context "when provided a symbol" do
-
-        before(:all) do
-          class Mountain
-            extend Finders
-          end
-        end
-
-        after(:all) do
-          Object.send(:remove_const, :Mountain)
-        end
-
-        Mongoid::Criteria::Queryable::Selectable.forwardables.each do |method|
-
-          it "forwards #{method} to the provided method name" do
-            expect(Mountain).to respond_to(method)
-          end
-        end
-
-        Mongoid::Criteria::Queryable::Optional.forwardables.each do |method|
-
-          it "forwards #{method} to the provided method name" do
-            expect(Mountain).to respond_to(method)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/all_spec.rb

@@ -1,31 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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 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
-
-        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: 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: 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

@@ -1,137 +0,0 @@
-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,106 +0,0 @@
-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