mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/composable_spec.rb

@@ -20,5 +20,12 @@ describe Mongoid::Composable do
         end
       end
     end
+
+    Mongoid::Composable::RESERVED_METHOD_NAMES.each do |name|
+
+      it "includes the method names #{name}" do
+        expect(methods).to include(name)
+      end
+    end
   end
 end

data/spec/mongoid/config_spec.rb

@@ -9,6 +9,12 @@ describe Mongoid::Config do
     end
   end
 
+  after do
+    Mongoid.configure do |config|
+      config.load_configuration(CONFIG)
+    end
+  end
+
   describe "#configured?" do
 
     after do
@@ -64,7 +70,7 @@ describe Mongoid::Config do
 
     before do
       if defined?(Rails)
-        RailsTemp = Rails
+        RailsTemp = Rails unless defined?(RailsTemp)
         Object.send(:remove_const, :Rails)
       end
 
@@ -82,34 +88,54 @@ describe Mongoid::Config do
     end
   end
 
-  context 'when the app_name is set in the config' do
-
-    let(:conf) do
-      CONFIG.merge(options: {app_name: 'admin-reporting'})
-    end
+  context 'when the belongs_to_required_by_default option is not set in the config' do
 
     before do
+      Mongoid::Config.reset
       Mongoid.configure do |config|
-        config.load_configuration(conf)
+        config.load_configuration(clients: CONFIG[:clients])
       end
     end
 
-    it 'sets the Mongoid.app_name to the provided value' do
-      expect(Mongoid.app_name).to eq('admin-reporting')
+    it 'sets the Mongoid.belongs_to_required_by_default value to true' do
+      expect(Mongoid.belongs_to_required_by_default).to be(true)
     end
   end
 
-  context 'when the app_name is not set in the config' do
+  context 'when the belongs_to_required_by_default option is set in the config' do
 
     before do
-      Mongoid::Config.reset
       Mongoid.configure do |config|
-        config.load_configuration(CONFIG)
+        config.load_configuration(conf)
       end
     end
 
-    it 'does not set the Mongoid.app_name option' do
-      expect(Mongoid.app_name).to be_nil
+    context 'when the value is set to true' do
+
+      let(:conf) do
+        CONFIG.merge(options: { belongs_to_required_by_default: true })
+      end
+
+      it 'sets the Mongoid.belongs_to_required_by_default value to true' do
+        expect(Mongoid.belongs_to_required_by_default).to be(true)
+      end
+    end
+
+    context 'when the value is set to false' do
+
+      let(:conf) do
+        CONFIG.merge(options: { belongs_to_required_by_default: false })
+      end
+
+      before do
+        Mongoid.configure do |config|
+          config.load_configuration(conf)
+        end
+      end
+
+      it 'sets the Mongoid.belongs_to_required_by_default value to false' do
+        expect(Mongoid.belongs_to_required_by_default).to be(false)
+      end
     end
   end
 
@@ -148,12 +174,6 @@ describe Mongoid::Config do
         described_class.load!(file, :test)
       end
 
-      after do
-        Mongoid.configure do |config|
-          config.load_configuration(CONFIG)
-        end
-      end
-
       it "sets the Mongoid logger level" do
         expect(Mongoid.logger.level).to eq(Logger::WARN)
       end
@@ -176,7 +196,7 @@ describe Mongoid::Config do
 
         after do
           if defined?(Rails)
-            RailsTemp = Rails
+            RailsTemp = Rails unless defined?(RailsTemp)
             Object.send(:remove_const, :Rails)
           end
         end

data/spec/mongoid/contextual/atomic_spec.rb

@@ -73,29 +73,6 @@ describe Mongoid::Contextual::Atomic do
         expect(smiths.reload.members).to eq([ "Dave" ])
       end
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.add_to_set(members: "Dave", genres: "Electro")
-      end
-
-      it "does not add duplicates" do
-        expect(depeche_mode.reload.members).to eq([ "Dave" ])
-      end
-
-      it "adds multiple operations" do
-        expect(depeche_mode.reload.genres).to eq([ "Electro" ])
-      end
-    end
   end
 
   describe "#bit" do
@@ -144,29 +121,6 @@ describe Mongoid::Contextual::Atomic do
         expect(depeche_mode.reload.likes).to eq(14)
       end
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ], likes: 60)
-      end
-
-      let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.bit(likes: { and: 13, or: 10 })
-      end
-
-      it "performs the bitwise operation on initialized fields" do
-        expect(depeche_mode.reload.likes).to eq(14)
-      end
-    end
   end
 
   describe "#inc" do
@@ -223,29 +177,6 @@ describe Mongoid::Contextual::Atomic do
         expect(beatles.reload.y).to eq(3)
       end
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.inc(years: 1)
-      end
-
-      it "incs the value and read from alias" do
-        expect(depeche_mode.reload.years).to eq(1)
-      end
-    end
   end
 
   describe "#pop" do
@@ -295,29 +226,6 @@ describe Mongoid::Contextual::Atomic do
         expect(smiths.reload.members).to be_nil
       end
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.pop(members: 1)
-      end
-
-      it "pops the last element off the array" do
-        expect(depeche_mode.reload.members).to be_empty
-      end
-    end
   end
 
   describe "#pull" do
@@ -349,276 +257,129 @@ describe Mongoid::Contextual::Atomic do
     it "does not error on non existent fields" do
       expect(smiths.reload.members).to be_nil
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let(:criteria) do
-        Band.where(members: [ "DAVE" ]).collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.pull(members: "DAVE")
-      end
-
-      it "pulls when the value is found" do
-        expect(depeche_mode.reload.members).to be_empty
-      end
-    end
   end
 
   describe "#pull_all" do
 
-    context 'when the criteria does not have a collation' do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave", "Alan", "Fletch" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
-
-      let(:criteria) do
-        Band.all
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.pull_all(members: [ "Alan", "Dave" ])
-      end
-
-      it "pulls when the values are found" do
-        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
-      end
-
-      it "does not error on non existent fields" do
-        expect(smiths.reload.members).to be_nil
-      end
+    let!(:depeche_mode) do
+      Band.create(members: [ "Dave", "Alan", "Fletch" ])
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
+    let!(:smiths) do
+      Band.create
+    end
 
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave", "Alan", "Fletch" ])
-      end
+    let(:criteria) do
+      Band.all
+    end
 
-      let(:criteria) do
-        Band.all.collation(locale: 'en_US', strength: 2)
-      end
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
 
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
+    before do
+      context.pull_all(members: [ "Alan", "Dave" ])
+    end
 
-      before do
-        context.pull_all(members: [ "ALAN", "DAVE" ])
-      end
+    it "pulls when the values are found" do
+      expect(depeche_mode.reload.members).to eq([ "Fletch" ])
+    end
 
-      it "pulls when the value is found" do
-        expect(depeche_mode.reload.members).to eq([ "Fletch" ])
-      end
+    it "does not error on non existent fields" do
+      expect(smiths.reload.members).to be_nil
     end
   end
 
   describe "#push" do
 
-    context 'when the criteria does not have a collation' do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
-
-      let(:criteria) do
-        Band.all
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.push(members: "Alan")
-      end
-
-      it "pushes the value to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
-      end
-
-      it "pushes to non existent fields" do
-        expect(smiths.reload.members).to eq([ "Alan" ])
-      end
+    let!(:depeche_mode) do
+      Band.create(members: [ "Dave" ])
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
+    let!(:smiths) do
+      Band.create
+    end
 
-      let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
-      end
+    let(:criteria) do
+      Band.all
+    end
 
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
 
-      before do
-        context.push(members: "Alan")
-      end
+    before do
+      context.push(members: "Alan")
+    end
 
-      it "pushes the value to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
-      end
+    it "pushes the value to existing arrays" do
+      expect(depeche_mode.reload.members).to eq([ "Dave", "Alan" ])
+    end
 
-      it "pushes to non existent fields" do
-        expect(smiths.reload.members).to be_nil
-      end
+    it "pushes to non existent fields" do
+      expect(smiths.reload.members).to eq([ "Alan" ])
     end
   end
 
-  describe "#push_each" do
+  describe "#push_all" do
 
-    context 'when the criteria does not have a collation' do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
-
-      let(:criteria) do
-        Band.all
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.push_each(members: [ "Alan", "Fletch" ])
-      end
-
-      it "pushes the values to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
-      end
-
-      it "pushes to non existent fields" do
-        expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
-      end
+    let!(:depeche_mode) do
+      Band.create(members: [ "Dave" ])
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
+    let!(:smiths) do
+      Band.create
+    end
 
-      let!(:smiths) do
-        Band.create
-      end
+    let(:criteria) do
+      Band.all
+    end
 
-      let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
-      end
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
 
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
+    before do
+      context.push_all(members: [ "Alan", "Fletch" ])
+    end
 
-      before do
-        context.push_each(members: [ "Alan", "Fletch" ])
-      end
+    it "pushes the values to existing arrays" do
+      expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
+    end
 
-      it "pushes the values to existing arrays" do
-        expect(depeche_mode.reload.members).to eq([ "Dave", "Alan", "Fletch" ])
-      end
+    it "pushes to non existent fields" do
+      expect(smiths.reload.members).to eq([ "Alan", "Fletch" ])
     end
   end
 
   describe "#rename" do
 
-    context 'when the criteria does not have a collation' do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
-
-      let(:criteria) do
-        Band.all
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.rename(members: :artists)
-      end
-
-      it "renames existing fields" do
-        expect(depeche_mode.reload.artists).to eq([ "Dave" ])
-      end
-
-      it "does not rename non existent fields" do
-        expect(smiths.reload).to_not respond_to(:artists)
-      end
+    let!(:depeche_mode) do
+      Band.create(members: [ "Dave" ])
     end
 
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(members: [ "Dave" ])
-      end
-
-      let!(:smiths) do
-        Band.create
-      end
+    let!(:smiths) do
+      Band.create
+    end
 
-      let(:criteria) do
-        Band.where(members: ['DAVE']).collation(locale: 'en_US', strength: 2)
-      end
+    let(:criteria) do
+      Band.all
+    end
 
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
 
-      before do
-        context.rename(members: :artists)
-      end
+    before do
+      context.rename(members: :artists)
+    end
 
-      it "renames existing fields" do
-        expect(depeche_mode.reload.artists).to eq([ "Dave" ])
-      end
+    it "renames existing fields" do
+      expect(depeche_mode.reload.artists).to eq([ "Dave" ])
+    end
 
-      it "does not rename non existent fields" do
-        expect(smiths.reload).to_not respond_to(:artists)
-      end
+    it "does not rename non existent fields" do
+      expect(smiths.reload).to_not respond_to(:artists)
     end
   end
 
@@ -748,32 +509,5 @@ describe Mongoid::Contextual::Atomic do
         end
       end
     end
-
-    context 'when the criteria has a collation', if: collation_supported? do
-
-      let!(:depeche_mode) do
-        Band.create(name: "Depeche Mode", years: 10)
-      end
-
-      let!(:new_order) do
-        Band.create(name: "New Order", years: 10)
-      end
-
-      let(:criteria) do
-        Band.where(name: 'DEPECHE MODE').collation(locale: 'en_US', strength: 2)
-      end
-
-      let(:context) do
-        Mongoid::Contextual::Mongo.new(criteria)
-      end
-
-      before do
-        context.unset(:name)
-      end
-
-      it "unsets the unaliased field" do
-        expect(depeche_mode.reload.name).to be_nil
-      end
-    end
   end
 end