mongoid 7.0.12 → 7.3.3

data/spec/integration/discriminator_key_spec.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "#discriminator_key" do 
+
+  context "when the discriminator key is not set on a class" do
+    let(:piano) do 
+      Piano.new
+    end
+
+    let(:guitar) do 
+      Guitar.new
+    end  
+    
+    it "sets the child discriminator key to _type: Piano" do
+      expect(piano._type).to eq("Piano")
+    end
+
+    it "sets the child discriminator key to _type: Guitar" do
+      expect(guitar._type).to eq("Guitar")
+    end
+  end
+  
+  context "when the discriminator key is changed in the parent" do
+    before do
+      Instrument.discriminator_key = "hello2"
+    end
+
+    after do
+      Instrument.discriminator_key = nil
+    end
+
+    let(:piano) do 
+      Piano.new
+    end
+
+    let(:guitar) do 
+      Guitar.new
+    end
+
+    it "changes in the child class: Piano" do
+      expect(piano.hello2).to eq("Piano")
+    end
+
+    it "changes in the child class: Guitar" do
+      expect(guitar.hello2).to eq("Guitar")
+    end
+  end
+
+  context "when the discriminator key is changed at the base level" do
+    context "after class creation" do
+      before do
+        class GlobalIntDiscriminatorParent
+          include Mongoid::Document
+        end
+        
+        class GlobalIntDiscriminatorChild < GlobalIntDiscriminatorParent
+        end
+        
+        Mongoid.discriminator_key = "test"
+      end
+
+      after do
+        Mongoid.discriminator_key = "_type"
+      end
+
+      let(:child) do 
+        GlobalIntDiscriminatorChild.new
+      end
+
+      it "has a discriminator key _type" do 
+        expect(child._type).to eq("GlobalIntDiscriminatorChild")
+      end
+
+      it "does not have the new global value as a field" do
+        expect(defined?(child.test)).to be nil
+      end
+    end
+
+    context "before class creation" do
+      before do
+        Mongoid.discriminator_key = "test"
+
+        class PreGlobalIntDiscriminatorParent
+          include Mongoid::Document
+        end
+        
+        class PreGlobalIntDiscriminatorChild < PreGlobalIntDiscriminatorParent
+        end
+      end
+
+      after do
+        Mongoid.discriminator_key = "_type"
+      end
+
+      let(:child) do 
+        PreGlobalIntDiscriminatorChild.new
+      end
+
+      it "creates a field with new discriminator key" do 
+        expect(child.test).to eq("PreGlobalIntDiscriminatorChild")
+      end
+      
+      it "does not have the default value as a field" do
+        expect(defined?(child._type)).to be nil
+      end
+    end
+  end
+
+  context "when the discriminator key is changed in the parent" do 
+    context "after child class creation" do
+      before do
+        class LocalIntDiscriminatorParent
+          include Mongoid::Document
+        end
+
+        class LocalIntDiscriminatorChild < LocalIntDiscriminatorParent
+        end
+
+        LocalIntDiscriminatorParent.discriminator_key = "test2"
+      end
+
+      let(:child) do 
+        LocalIntDiscriminatorChild.new
+      end
+
+      it "still has _type field in the child" do 
+        expect(child._type).to include("LocalIntDiscriminatorChild")
+      end
+
+      it "has the new field in the child" do 
+        expect(child.test2).to include("LocalIntDiscriminatorChild")
+      end
+    end
+
+    context "before child class creation" do
+      before do
+        class PreLocalIntDiscriminatorParent
+          include Mongoid::Document
+          self.discriminator_key = "test2"
+        end
+
+        class PreLocalIntDiscriminatorChild < PreLocalIntDiscriminatorParent
+        end
+      end
+
+      let(:child) do 
+        PreLocalIntDiscriminatorChild.new
+      end
+
+      it "creates a new field in the child" do 
+        expect(child.test2).to include("PreLocalIntDiscriminatorChild")
+      end
+
+      it "does not have the default value as a field" do
+        expect(defined?(child._type)).to be nil
+      end
+    end
+  end
+
+  context "when adding to the db" do 
+    context "when changing the discriminator_key" do
+      before do 
+        class DBDiscriminatorParent
+          include Mongoid::Document
+          self.discriminator_key = "dkey"
+        end
+
+        class DBDiscriminatorChild < DBDiscriminatorParent
+        end
+        DBDiscriminatorChild.create!
+      end
+      
+      it "has the correct count" do 
+        expect(DBDiscriminatorChild.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(DBDiscriminatorParent.count).to eq(1)
+      end
+    end
+
+    context "when changing the discriminator_key after saving to the db" do
+      before do 
+        class DBDiscriminatorParent
+          include Mongoid::Document
+        end
+        
+        class DBDiscriminatorChild < DBDiscriminatorParent
+        end
+        DBDiscriminatorChild.create!
+        DBDiscriminatorParent.discriminator_key = "dkey2"
+        DBDiscriminatorChild.create!
+      end
+      
+      it "only finds the documents with the new discriminator key" do 
+        expect(DBDiscriminatorChild.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(DBDiscriminatorParent.count).to eq(2)
+      end
+    end
+  end
+
+  context "documentation tests" do
+
+    context "Example 1" do
+      before do
+        class Example1Shape
+          include Mongoid::Document
+          field :x, type: Integer
+          field :y, type: Integer
+          embedded_in :canvas
+  
+          self.discriminator_key = "shape_type"
+        end
+  
+        class Example1Circle < Example1Shape
+          field :radius, type: Float
+        end
+  
+        class Example1Rectangle < Example1Shape
+          field :width, type: Float
+          field :height, type: Float
+        end
+      end
+  
+      let(:rectangle) do 
+        Example1Rectangle.new
+      end
+  
+      let(:circle) do 
+        Example1Circle.new
+      end
+  
+      it "has the new discriminator key: Rectangle" do 
+        expect(rectangle.shape_type).to eq("Example1Rectangle")
+      end
+  
+      it "does not have the default discriminator key: Rectangle" do
+        expect(defined?(rectangle._type)).to be nil
+      end
+  
+      it "has the new discriminator key: Circle" do 
+        expect(circle.shape_type).to eq("Example1Circle")
+      end
+  
+      it "does not have the default discriminator key: Circle" do
+        expect(defined?(circle._type)).to be nil
+      end
+    end
+  
+    context "Example 2" do
+      before do
+        class Example2Shape
+          include Mongoid::Document
+          field :x, type: Integer
+          field :y, type: Integer
+          embedded_in :canvas
+        end
+  
+        class Example2Circle < Example2Shape
+          field :radius, type: Float
+        end
+  
+        class Example2Rectangle < Example2Shape
+          field :width, type: Float
+          field :height, type: Float
+        end
+  
+        Example2Shape.discriminator_key = "shape_type"
+      end
+  
+      let(:rectangle) do 
+        Example2Rectangle.new
+      end
+  
+      let(:circle) do 
+        Example2Circle.new
+      end
+  
+      it "has the new discriminator key: Rectangle" do 
+        expect(rectangle.shape_type).to eq("Example2Rectangle")
+      end
+  
+      it "has default discriminator key: Rectangle" do
+        expect(rectangle._type).to eq("Example2Rectangle")
+      end
+  
+      it "has the new discriminator key: Circle" do 
+        expect(circle.shape_type).to eq("Example2Circle")
+      end
+  
+      it "has default discriminator key: Circle" do
+        expect(circle._type).to eq("Example2Circle")
+      end
+    end
+  
+    context "Example 3" do
+      before do
+  
+        Mongoid.discriminator_key = "shape_type"
+        
+        class Example3Shape
+          include Mongoid::Document
+          field :x, type: Integer
+          field :y, type: Integer
+          embedded_in :canvas
+        end
+  
+        class Example3Circle < Example3Shape
+          field :radius, type: Float
+        end
+  
+        class Example3Rectangle < Example3Shape
+          field :width, type: Float
+          field :height, type: Float
+        end
+  
+      end
+
+      after do 
+        Mongoid.discriminator_key = "_type"
+      end
+  
+      let(:rectangle) do 
+        Example3Rectangle.new
+      end
+  
+      let(:circle) do 
+        Example3Circle.new
+      end
+  
+      it "has the new discriminator key: Rectangle" do 
+        expect(rectangle.shape_type).to eq("Example3Rectangle")
+      end
+  
+      it "does not have the default discriminator key: Rectangle" do
+        expect(defined?(rectangle._type)).to be nil
+      end
+  
+      it "has the new discriminator key: Circle" do 
+        expect(circle.shape_type).to eq("Example3Circle")
+      end
+  
+      it "does not have the default discriminator key: Circle" do
+        expect(defined?(circle._type)).to be nil
+      end
+    end
+  end
+end

data/spec/integration/discriminator_value_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "#discriminator_key" do 
+
+  context "when the discriminator value is not set on a class" do
+    let(:piano) do 
+      Piano.new
+    end
+
+    let(:guitar) do 
+      Guitar.new
+    end  
+    
+    it "sets the child discriminator key to _type: Piano" do
+      expect(piano._type).to eq("Piano")
+    end
+
+    it "sets the child discriminator key to _type: Guitar" do
+      expect(guitar._type).to eq("Guitar")
+    end
+  end
+
+  context "when the discriminator_value is set on a child" do
+    before do 
+      Piano.discriminator_value = "keys"
+    end
+
+    after do 
+      Piano.discriminator_value = nil
+    end
+
+    let(:piano) do 
+      Piano.new
+    end
+
+    it "has the correct discriminator value on the instance" do 
+      expect(piano._type).to eq("keys")
+    end
+  end
+
+  context "when the discriminator key and value are set on a child" do
+    before do 
+      Piano.discriminator_value = "keys"
+      Instrument.discriminator_key = "dkey"
+    end
+
+    after do 
+      Piano.discriminator_value = nil
+      Instrument.discriminator_key = nil
+    end
+
+
+    let(:piano) do 
+      Piano.new
+    end
+
+    it "has the correct discriminator value on the instance" do 
+      expect(piano.dkey).to eq("keys")
+    end
+  end
+
+  context "when adding to the db" do
+    context "when not changing the discriminator value" do 
+      before do 
+        Piano.create!
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when changing the discriminator value" do 
+      before do 
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when changing the discriminator key/value" do 
+      before do 
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when calling count before changing the discriminator key/value" do 
+      before do 
+        Instrument.count
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when calling create before changing the discriminator key/value" do 
+      before do 
+        Piano.create!
+        Instrument.discriminator_key = "dkey"
+        Piano.discriminator_value = "keys"
+        Piano.create!
+      end
+
+      after do 
+        Instrument.discriminator_key = nil
+        Piano.discriminator_value = nil
+      end
+
+      it "has the correct count" do 
+        expect(Piano.count).to eq(1)
+      end
+
+      it "has the correct count in the parent" do 
+        expect(Instrument.count).to eq(2)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+
+    context "when there exists an unrecognizable discriminator value in the database" do 
+      before do 
+        Piano.discriminator_value = "keys"
+        Piano.create!(_type: "dvalue")
+      end
+
+      after do 
+        Piano.discriminator_value = nil
+      end
+
+      it "is not considered a piano" do 
+        expect(Piano.count).to eq(0)
+      end
+
+      it "is considered an Instrument, the parent" do 
+        expect(Instrument.count).to eq(1)
+      end
+
+      it "has zero count in the sibling" do 
+        expect(Guitar.count).to eq(0)
+      end
+    end
+  end
+end

data/spec/integration/document_spec.rb

@@ -19,4 +19,34 @@ describe Mongoid::Document do
       DelegatingPatient.default_client.should be Mongoid.default_client
     end
   end
+
+  context 'when id is unaliased' do
+    it 'persists separate id and _id values' do
+      shirt = Shirt.create!(id: 'hello', _id: 'foo')
+      shirt = Shirt.find(shirt._id)
+      shirt.id.should == 'hello'
+      shirt._id.should == 'foo'
+    end
+  end
+
+  describe '#reload' do
+    context 'when changing shard key value' do
+      require_topology :sharded
+
+      let(:profile) do
+        # Profile shard_key :name
+        Profile.create!(name: "Alice")
+      end
+
+      it "successfully reloads the document after saving an update to the sharded field" do
+        expect(profile.name).to eq("Alice")
+        profile.name = "Bob"
+        profile.save!
+
+        profile.reload
+
+        expect(profile.name).to eq("Bob")
+      end
+    end
+  end
 end

data/spec/integration/i18n_fallbacks_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'i18n fallbacks' do
+  # These tests modify the environment
+  before(:all) do
+    unless %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
+      skip 'Set TEST_I18N_FALLBACKS=1 environment variable to run these tests'
+    end
+  end
+
+  before(:all) do
+    puts "I18n version: #{I18n::VERSION}"
+
+    require "i18n/backend/fallbacks"
+    I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+  end
+
+  context 'when fallbacks are enabled with a locale list' do
+    before do
+      I18n.default_locale = :en
+      I18n.fallbacks[:de] = [ :en ]
+    end
+
+    context 'when translation is present in active locale' do
+      it 'uses active locale' do
+        product = Product.new
+        I18n.locale = :de
+        product.description = "Marvelous in German"
+        I18n.locale = :en
+        product.description = "Marvelous!"
+        I18n.locale = :de
+        product.description.should == 'Marvelous in German'
+      end
+    end
+
+    context 'when translation is missing in active locale and present in fallback locale' do
+
+      it 'falls back on default locale' do
+        product = Product.new
+        I18n.locale = :en
+        product.description = "Marvelous!"
+        I18n.locale = :de
+        product.description.should == 'Marvelous!'
+      end
+
+    end
+
+    context 'when translation is missing in all locales' do
+
+      context 'i18n >= 1.1' do
+
+        before(:all) do
+          unless Gem::Version.new(I18n::VERSION) >= Gem::Version.new('1.1')
+            skip "Test requires i18n >= 1.1, we have #{I18n::VERSION}"
+          end
+        end
+
+        it 'returns nil' do
+          product = Product.new
+          I18n.locale = :en
+          product.description = "Marvelous!"
+          I18n.locale = :ru
+          product.description.should be nil
+        end
+
+      end
+
+      context 'i18n 1.0' do
+
+        before(:all) do
+          unless Gem::Version.new(I18n::VERSION) < Gem::Version.new('1.1')
+            skip "Test requires i18n < 1.1, we have #{I18n::VERSION}"
+          end
+        end
+
+        it 'falls back on default locale' do
+          product = Product.new
+          I18n.locale = :en
+          product.description = "Marvelous!"
+          I18n.locale = :ru
+          product.description.should == 'Marvelous!'
+        end
+
+      end
+    end
+  end
+end