mongoid 8.0.13 → 8.1.0

data/spec/mongoid/clients/factory_spec.rb

@@ -29,32 +29,6 @@ describe Mongoid::Clients::Factory do
     end
   end
 
-  shared_examples_for 'includes rails wrapping library' do
-    context 'when Rails is available' do
-      around do |example|
-        original_rails_constant = defined?(::Rails) ? ::Rails : nil
-        Object.send(:remove_const, :Rails) if original_rails_constant
-
-        module ::Rails
-          def self.version
-            '6.1.0'
-          end
-        end
-
-        example.run
-
-        Object.send(:remove_const, :Rails) if defined?(::Rails)
-        Object.const_set(:Rails, original_rails_constant)
-      end
-
-      it 'adds Rails as another wrapping library' do
-        expect(client.options[:wrapping_libraries]).to include(
-          {'name' => 'Rails', 'version' => '6.1.0'},
-        )
-      end
-    end
-  end
-
   describe ".create" do
 
     context "when provided a name" do
@@ -114,8 +88,6 @@ describe Mongoid::Clients::Factory do
               Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY)]
           end
 
-          it_behaves_like 'includes rails wrapping library'
-
           context 'when configuration specifies a wrapping library' do
 
             let(:config) do
@@ -137,8 +109,6 @@ describe Mongoid::Clients::Factory do
                 {'name' => 'Foo'},
               ]
             end
-
-            it_behaves_like 'includes rails wrapping library'
           end
         end
 

data/spec/mongoid/clients_spec.rb

@@ -738,19 +738,6 @@ describe Mongoid::Clients do
       end
     end
 
-    context "when provided a class that extends another document" do
-
-      let(:klass) do
-        Class.new(Band)
-      end
-
-      it "raises an error" do
-        expect {
-          klass.store_in(database: :artists)
-        }.to raise_error(Mongoid::Errors::InvalidStorageParent)
-      end
-    end
-
     context "when provided a hash" do
 
       context "when the hash is not valid" do
@@ -762,6 +749,128 @@ describe Mongoid::Clients do
         end
       end
     end
+
+    context "when it is called on a subclass" do
+
+      let(:client) { StoreParent.collection.client }
+      let(:parent) { StoreParent.create! }
+      let(:child1) { StoreChild1.create! }
+      let(:child2) { StoreChild2.create! }
+
+      before do
+        class StoreParent
+          include Mongoid::Document
+        end
+
+        class StoreChild1 < StoreParent
+        end
+
+        class StoreChild2 < StoreParent
+        end
+      end
+
+      after do
+        Object.send(:remove_const, :StoreParent)
+        Object.send(:remove_const, :StoreChild1)
+        Object.send(:remove_const, :StoreChild2)
+      end
+
+      context "when it is not called on the parent" do
+
+        context "when it is called on all subclasses" do
+
+          before do
+            StoreChild1.store_in collection: :store_ones
+            StoreChild2.store_in collection: :store_twos
+            [ parent, child1, child2 ]
+          end
+
+          let(:db_parent) { client['store_parents'].find.first }
+          let(:db_child1) { client['store_ones'].find.first }
+          let(:db_child2) { client['store_twos'].find.first }
+
+          it "stores the documents in the correct collections" do
+            expect(db_parent).to eq({ "_id" => parent.id, "_type" => "StoreParent" })
+            expect(db_child1).to eq({ "_id" => child1.id, "_type" => "StoreChild1" })
+            expect(db_child2).to eq({ "_id" => child2.id, "_type" => "StoreChild2" })
+          end
+
+          it "only queries from its own collections" do
+            expect(StoreParent.count).to eq(1)
+            expect(StoreChild1.count).to eq(1)
+            expect(StoreChild2.count).to eq(1)
+          end
+        end
+
+        context "when it is called on one of the subclasses" do
+
+          before do
+            StoreChild1.store_in collection: :store_ones
+            [ parent, child1, child2 ]
+          end
+
+          let(:db_parent) { client['store_parents'].find.first }
+          let(:db_child1) { client['store_ones'].find.first }
+          let(:db_child2) { client['store_parents'].find.to_a.last }
+
+          it "stores the documents in the correct collections" do
+            expect(db_parent).to eq({ "_id" => parent.id, "_type" => "StoreParent" })
+            expect(db_child1).to eq({ "_id" => child1.id, "_type" => "StoreChild1" })
+            expect(db_child2).to eq({ "_id" => child2.id, "_type" => "StoreChild2" })
+          end
+
+          it "queries from its own collections" do
+            expect(StoreParent.count).to eq(2)
+            expect(StoreChild1.count).to eq(1)
+            expect(StoreChild2.count).to eq(1)
+          end
+        end
+      end
+
+      context "when it is called on the parent" do
+
+        before do
+          StoreParent.store_in collection: :st_parents
+        end
+
+        context "when it is called on all subclasses" do
+
+          before do
+            StoreChild1.store_in collection: :store_ones
+            StoreChild2.store_in collection: :store_twos
+            [ parent, child1, child2 ]
+          end
+
+          let(:db_parent) { client['st_parents'].find.first }
+          let(:db_child1) { client['store_ones'].find.first }
+          let(:db_child2) { client['store_twos'].find.first }
+
+          it "stores the documents in the correct collections" do
+            expect(db_parent).to eq({ "_id" => parent.id, "_type" => "StoreParent" })
+            expect(db_child1).to eq({ "_id" => child1.id, "_type" => "StoreChild1" })
+            expect(db_child2).to eq({ "_id" => child2.id, "_type" => "StoreChild2" })
+          end
+        end
+
+        context "when it is called on one of the subclasses" do
+
+          before do
+            StoreChild1.store_in collection: :store_ones
+            [ parent, child1, child2 ]
+          end
+
+          let(:db_parent) { client['st_parents'].find.first }
+          let(:db_child1) { client['store_ones'].find.first }
+          let(:db_child2) { client['st_parents'].find.to_a.last }
+
+          it "stores the documents in the correct collections" do
+            expect(db_parent).to eq({ "_id" => parent.id, "_type" => "StoreParent" })
+            expect(db_child1).to eq({ "_id" => child1.id, "_type" => "StoreChild1" })
+            expect(db_child2).to eq({ "_id" => child2.id, "_type" => "StoreChild2" })
+          end
+        end
+      end
+    end
   end
 
   describe ".with" do

data/spec/mongoid/collection_configurable_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::CollectionConfigurable do
+
+  before(:all) do
+    class CollectionConfigurableValidOptions
+      include Mongoid::Document
+
+      store_in collection_options: {
+        capped: true,
+        size: 2560
+      }
+    end
+
+    class CollectionConfigurableUnknownOptions
+      include Mongoid::Document
+
+      store_in collection_options: {
+        i_am_not_an_option: true,
+        let_me: { fail: true }
+      }
+    end
+
+    class CollectionConfigurableInvalidOptions
+      include Mongoid::Document
+
+      store_in collection_options: {
+        capped: true
+        # Creating a capped collection requires `size` field; therefore,
+        # an attempt to create a collection with only `capped : true` option
+        # fails.
+      }
+    end
+  end
+
+  after(:all) do
+    Mongoid.deregister_model(CollectionConfigurableValidOptions)
+    Object.send(:remove_const, :CollectionConfigurableValidOptions)
+    Mongoid.deregister_model(CollectionConfigurableUnknownOptions)
+    Object.send(:remove_const, :CollectionConfigurableUnknownOptions)
+    Mongoid.deregister_model(CollectionConfigurableInvalidOptions)
+    Object.send(:remove_const, :CollectionConfigurableInvalidOptions)
+  end
+
+  after(:each) do
+    [
+      CollectionConfigurableValidOptions,
+      CollectionConfigurableUnknownOptions
+    ].each do |klazz|
+      klazz.collection.drop
+    end
+  end
+
+  context 'when collection does not exist' do
+    context 'with valid options' do
+      let(:subject) do
+        CollectionConfigurableValidOptions
+      end
+
+      before(:each) do
+        subject.create_collection
+      end
+
+      let(:coll_options) do
+        subject.collection.database.list_collections(filter: { name: subject.collection_name.to_s }).first
+      end
+
+      it 'creates the collection' do
+        expect(coll_options).not_to be_nil
+      end
+
+      it 'passes collection options' do
+        expect(coll_options.dig('options', 'capped')).to eq(true)
+        expect(coll_options.dig('options', 'size')).to eq(2560)
+      end
+    end
+
+    context 'with an unknown collection options' do
+      let(:subject) do
+        CollectionConfigurableUnknownOptions
+      end
+
+      it 'raises an error' do
+        expect do
+          subject.create_collection
+        end.to raise_error(Mongoid::Errors::CreateCollectionFailure)
+      end
+    end
+
+    context 'with invalid options' do
+      let(:subject) do
+        CollectionConfigurableInvalidOptions
+      end
+
+      it 'raises an error' do
+        expect do
+          subject.create_collection
+        end.to raise_error(Mongoid::Errors::CreateCollectionFailure)
+      end
+    end
+  end
+
+  context 'when collection exists' do
+    let(:subject) do
+      CollectionConfigurableValidOptions
+    end
+
+    context 'when force is false' do
+      let(:logger) do
+        double("logger").tap do |log|
+          expect(log).to receive(:debug).once.with(/Collection '#{subject.collection_name}' already exist/)
+        end
+      end
+
+      before do
+        allow(subject).to receive(:logger).and_return(logger)
+        subject.collection.create
+      end
+
+      it 'logs a message' do
+        subject.create_collection
+      end
+    end
+
+    context 'when force is true' do
+      let(:logger) do
+        double("logger")
+      end
+
+      let(:coll_options) do
+        subject.collection.database.list_collections(filter: { name: subject.collection_name.to_s }).first
+      end
+
+      before do
+        allow(subject).to receive(:logger).and_return(logger)
+        subject.collection.create
+      end
+
+      it 'does not log a message' do
+        expect(logger).to receive(:debug).never.with(/Collection '#{subject.collection_name}' already exist/)
+        subject.create_collection(force: true)
+      end
+
+      it 'creates the collection' do
+        subject.create_collection(force: true)
+        expect(coll_options).not_to be_nil
+      end
+
+      it 'passes collection options' do
+        subject.create_collection(force: true)
+        expect(coll_options.dig('options', 'capped')).to eq(true)
+        expect(coll_options.dig('options', 'size')).to eq(2560)
+      end
+    end
+  end
+end

data/spec/mongoid/config/defaults_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Config::Defaults do
+
+  let(:config) do
+    Mongoid::Config
+  end
+
+  describe ".load_defaults" do
+
+    shared_examples "uses settings for 7.3" do
+      it "uses settings for 7.3" do
+        expect(Mongoid.broken_aggregables).to be true
+        expect(Mongoid.broken_alias_handling).to be true
+        expect(Mongoid.broken_and).to be true
+        expect(Mongoid.broken_scoping).to be true
+        expect(Mongoid.broken_updates).to be true
+        expect(Mongoid.compare_time_by_ms).to be false
+        expect(Mongoid.legacy_pluck_distinct).to be true
+        expect(Mongoid.legacy_triple_equals).to be true
+        expect(Mongoid.object_id_as_json_oid).to be true
+      end
+    end
+
+    shared_examples "does not use settings for 7.3" do
+      it "does not use settings for 7.3" do
+        expect(Mongoid.broken_aggregables).to be false
+        expect(Mongoid.broken_alias_handling).to be false
+        expect(Mongoid.broken_and).to be false
+        expect(Mongoid.broken_scoping).to be false
+        expect(Mongoid.broken_updates).to be false
+        expect(Mongoid.compare_time_by_ms).to be true
+        expect(Mongoid.legacy_pluck_distinct).to be false
+        expect(Mongoid.legacy_triple_equals).to be false
+      end
+    end
+
+    shared_examples "uses settings for 7.4" do
+      it "uses settings for 7.4" do
+        expect(Mongoid.legacy_attributes).to be true
+        expect(Mongoid.overwrite_chained_operators).to be true
+      end
+    end
+
+    shared_examples "does not use settings for 7.4" do
+      it "does not use settings for 7.4" do
+        expect(Mongoid.legacy_attributes).to be false
+        expect(Mongoid.overwrite_chained_operators).to be false
+      end
+    end
+
+    shared_examples "uses settings for 7.5" do
+      it "uses settings for 7.5" do
+        expect(Mongoid.map_big_decimal_to_decimal128).to be false
+      end
+    end
+
+    shared_examples "does not use settings for 7.5" do
+      it "does not use settings for 7.5" do
+        expect(Mongoid.map_big_decimal_to_decimal128).to be true
+      end
+    end
+
+    shared_examples "uses settings for 8.0" do
+      it "uses settings for 8.0" do
+        expect(Mongoid.legacy_readonly).to be true
+      end
+    end
+
+    shared_examples "does not use settings for 8.0" do
+      it "does not use settings for 8.0" do
+        expect(Mongoid.legacy_readonly).to be false
+      end
+    end
+
+    shared_examples "uses settings for 8.1" do
+      it "uses settings for 8.1" do
+        expect(Mongoid.immutable_ids).to be false
+      end
+    end
+
+    context "when giving a valid version" do
+
+      before do
+        config.load_defaults(version)
+      end
+
+      after do
+        Mongoid::Config.reset
+      end
+
+      context "when the given version is 7.3" do
+
+        let(:version) { 7.3 }
+
+        it_behaves_like "uses settings for 7.3"
+        it_behaves_like "uses settings for 7.4"
+        it_behaves_like "uses settings for 7.5"
+        it_behaves_like "uses settings for 8.0"
+        it_behaves_like "uses settings for 8.1"
+      end
+
+      context "when the given version is 7.4" do
+
+        let(:version) { 7.4 }
+
+        it_behaves_like "does not use settings for 7.3"
+        it_behaves_like "uses settings for 7.4"
+        it_behaves_like "uses settings for 7.5"
+        it_behaves_like "uses settings for 8.0"
+        it_behaves_like "uses settings for 8.1"
+      end
+
+      context "when the given version is 7.5" do
+
+        let(:version) { 7.5 }
+
+        it_behaves_like "does not use settings for 7.3"
+        it_behaves_like "does not use settings for 7.4"
+        it_behaves_like "uses settings for 7.5"
+        it_behaves_like "uses settings for 8.0"
+        it_behaves_like "uses settings for 8.1"
+      end
+
+      context "when the given version is 8.0" do
+
+        let(:version) { 8.0 }
+
+        it_behaves_like "does not use settings for 7.3"
+        it_behaves_like "does not use settings for 7.4"
+        it_behaves_like "does not use settings for 7.5"
+        it_behaves_like "uses settings for 8.0"
+        it_behaves_like "uses settings for 8.1"
+      end
+
+      context "when the given version is 8.1" do
+
+        let(:version) { 8.1 }
+
+        it_behaves_like "does not use settings for 7.3"
+        it_behaves_like "does not use settings for 7.4"
+        it_behaves_like "does not use settings for 7.5"
+        it_behaves_like "does not use settings for 8.0"
+        it_behaves_like "uses settings for 8.1"
+      end
+    end
+
+    context "when given version an invalid version" do
+      let(:version) { 4.2 }
+
+      it "raises an error" do
+        expect do
+          config.load_defaults(version)
+        end.to raise_error(ArgumentError, /Unknown version: 4.2/)
+      end
+    end
+  end
+end