mongoid 7.1.11 → 7.2.0.rc1

data/spec/integration/associations/embeds_many_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'embeds_many associations' do
-
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:canvas) do
-        Canvas.create!(shapes: [Shape.new])
-      end
-
-      let!(:shape) { canvas.shapes.first }
-
-      it 'does not destroy the dependent object' do
-        canvas.shapes = [shape]
-        canvas.save!
-        canvas.reload
-        canvas.shapes.should == [shape]
-      end
-    end
-  end
-end

data/spec/integration/associations/embeds_one_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'embeds_one associations' do
-
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:canvas) do
-        Canvas.create!(palette: Palette.new)
-      end
-
-      let!(:palette) { canvas.palette }
-
-      it 'does not destroy the dependent object' do
-        canvas.palette = canvas.palette
-        canvas.save!
-        canvas.reload
-        canvas.palette.should == palette
-      end
-    end
-  end
-end

data/spec/integration/callbacks_models.rb

@@ -1,49 +0,0 @@
-class Galaxy
-  include Mongoid::Document
-
-  field :age, type: Integer
-
-  before_validation :set_age
-
-  embeds_many :stars
-
-  private
-
-  def set_age
-    self.age ||= 100_000
-  end
-end
-
-class Star
-  include Mongoid::Document
-
-  embedded_in :galaxy
-
-  field :age, type: Integer
-
-  before_validation :set_age
-
-  embeds_many :planets
-
-  private
-
-  def set_age
-    self.age ||= 42_000
-  end
-end
-
-class Planet
-  include Mongoid::Document
-
-  embedded_in :star
-
-  field :age, type: Integer
-
-  before_validation :set_age
-
-  private
-
-  def set_age
-    self.age ||= 2_000
-  end
-end

data/spec/integration/callbacks_spec.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-require_relative './callbacks_models'
-
-describe 'callbacks integration tests' do
-  context 'when modifying attributes in a callback' do
-
-    context 'when creating top-level document' do
-      context 'top level document' do
-        let(:instance) do
-          Galaxy.create!
-        end
-
-        it 'writes the attribute value into the model' do
-          instance.age.should == 100_000
-        end
-
-        it 'persists the attribute value' do
-          Galaxy.find(instance.id).age.should == 100_000
-        end
-      end
-
-      context 'embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.age.should == 42_000
-          end
-
-          it 'persists the attribute value' do
-            Galaxy.find(instance.id).stars.first.age.should == 42_000
-          end
-        end
-
-        context 'set as a document instance' do
-          let(:instance) do
-            Galaxy.create!(stars: [Star.new])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          let(:instance) do
-            Galaxy.create!(stars: [{}])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-
-      context 'nested embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.planets.first.age.should == 2_000
-          end
-
-          it 'persists the attribute value' do
-            Galaxy.find(instance.id).stars.first.planets.first.age.should == 2_000
-          end
-        end
-
-        context 'set as a document instance' do
-          let(:instance) do
-            Galaxy.create!(stars: [Star.new(
-              planets: [Planet.new],
-            )])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          let(:instance) do
-            Galaxy.create!(stars: [
-              planets: [{}],
-            ])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-    end
-
-    context 'when updating top-level document via #save' do
-      let!(:instance) do
-        Galaxy.create!
-      end
-
-      context 'embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.age.should == 42_000
-          end
-
-          it 'persists the attribute value' do
-            Galaxy.find(instance.id).stars.first.age.should == 42_000
-          end
-        end
-
-        context 'set as a document instance' do
-          before do
-            instance.stars = [Star.new]
-            instance.save!
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          before do
-            instance.stars = [{}]
-            instance.save!
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-
-      context 'nested embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.planets.first.age.should == 2_000
-          end
-
-          it 'persists the attribute value' do
-            Galaxy.find(instance.id).stars.first.planets.first.age.should == 2_000
-          end
-        end
-
-        context 'set as a document instance' do
-          before do
-            instance.stars = [Star.new(planets: [Planet.new])]
-            instance.save!
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          before do
-            instance.stars = [planets: [{}]]
-            instance.save!
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-    end
-
-    context 'when updating top-level document via #update_attributes' do
-      let!(:instance) do
-        Galaxy.create!
-      end
-
-      context 'embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.age.should == 42_000
-          end
-
-          it 'persists the attribute value' do
-            Galaxy.find(instance.id).stars.first.age.should == 42_000
-          end
-        end
-
-        context 'set as a document instance' do
-          before do
-            instance.update_attributes(stars: [Star.new])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          before do
-            instance.update_attributes(stars: [{}])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-
-      context 'nested embedded document' do
-        shared_examples 'persists the attribute value' do
-          it 'writes the attribute value into the model' do
-            instance.stars.first.planets.first.age.should == 2_000
-          end
-
-          it 'persists the attribute value' do
-            pending 'MONGOID-4476'
-
-            Galaxy.find(instance.id).stars.first.planets.first.age.should == 2_000
-          end
-        end
-
-        context 'set as a document instance' do
-          before do
-            instance.update_attributes(stars: [Star.new(planets: [Planet.new])])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-
-        context 'set as attributes on parent' do
-          before do
-            instance.update_attributes(stars: [planets: [{}]])
-          end
-
-          include_examples 'persists the attribute value'
-        end
-      end
-    end
-  end
-end

data/spec/integration/contextual/empty_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Contextual classes when dealing with empty result set' do
-  shared_examples 'behave as expected' do
-    context '#exists?' do
-      it 'is false' do
-        context.exists?.should be false
-      end
-    end
-
-    context '#count' do
-      it 'is 0' do
-        context.count.should == 0
-      end
-    end
-
-    context '#length' do
-      it 'is 0' do
-        context.length.should == 0
-      end
-    end
-
-    # #estimated_count only exists for Mongo
-
-    context '#distinct' do
-      it 'is empty array' do
-        context.distinct(:foo).should == []
-      end
-    end
-
-    context '#each' do
-      context 'with block' do
-        it 'does not invoke the block' do
-          called = false
-          context.each do
-            called = true
-          end
-          called.should be false
-        end
-      end
-
-      context 'without block' do
-        it 'returns Enumerable' do
-          context.each.should be_a(Enumerable)
-        end
-
-        it 'returns empty Enumerable' do
-          context.each.to_a.should == []
-        end
-      end
-    end
-
-    context '#map' do
-      context 'with block' do
-        it 'does not invoke the block' do
-          called = false
-          context.map do
-            called = true
-          end
-          called.should be false
-        end
-      end
-
-      context 'without block' do
-        it 'returns empty array' do
-          skip 'MONGOID-5148'
-
-          context.map(:field).should == []
-        end
-      end
-    end
-
-    context '#first' do
-      it 'is nil' do
-        context.first.should be nil
-      end
-    end
-
-    context '#find_first' do
-      it 'is nil' do
-        context.find_first.should be nil
-      end
-    end
-
-    context '#one' do
-      it 'is nil' do
-        context.one.should be nil
-      end
-    end
-
-    context '#last' do
-      it 'is nil' do
-        context.last.should be nil
-      end
-    end
-  end
-
-  let(:context) do
-    context_cls.new(criteria)
-  end
-
-  before do
-    # Create an object of the same class used in the Criteria instance
-    # to verify we are using the Contextual classes.
-    Mop.create!
-  end
-
-  context 'Mongo' do
-    let(:context_cls) { Mongoid::Contextual::Mongo }
-
-    let(:criteria) do
-      Mop.and(Mop.where(a: 1), Mop.where(a: 2))
-    end
-
-    include_examples 'behave as expected'
-  end
-
-  context 'Memory' do
-    let(:context_cls) { Mongoid::Contextual::Memory }
-
-    let(:criteria) do
-      Mop.all.tap do |criteria|
-        criteria.documents = []
-      end
-    end
-
-    include_examples 'behave as expected'
-  end
-
-  context 'None' do
-    let(:context_cls) { Mongoid::Contextual::None }
-
-    let(:criteria) do
-      Mop.none
-    end
-
-    include_examples 'behave as expected'
-  end
-end

data/spec/mongoid/errors/invalid_config_file_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Errors::InvalidConfigFile do
-
-  describe "#message" do
-
-    let(:error) do
-      described_class.new('/my/path')
-    end
-
-    it "contains the problem in the message" do
-      expect(error.message).to include(
-        "Invalid configuration file: /my/path."
-      )
-    end
-
-    it "contains the summary in the message" do
-      expect(error.message).to include(
-        "Your mongoid.yml configuration file does not contain the"
-      )
-    end
-
-    it "contains the resolution in the message" do
-      expect(error.message).to include(
-        "Ensure your configuration file contains the correct contents."
-      )
-    end
-  end
-end

data/spec/mongoid/matchable/all_spec.rb

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