mongoid 7.1.0 → 7.1.1

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

@@ -2450,6 +2450,58 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+
+    context 'when using an MQL logical operator manually' do
+      let(:base_query) do
+        query.where(test: 1)
+      end
+
+      let(:selection) do
+        base_query.where(mql_operator => ['hello' => 'world'])
+      end
+
+      shared_examples_for 'adds conditions to existing query' do
+        it 'adds conditions to existing query' do
+          selection.selector.should == {
+            'test' => 1,
+            mql_operator => ['hello' => 'world'],
+          }
+        end
+      end
+
+      shared_examples_for 'adds conditions to existing query with an extra $and' do
+        it 'adds conditions to existing query' do
+          selection.selector.should == {
+            'test' => 1,
+            mql_operator => ['hello' => 'world'],
+          }
+        end
+      end
+
+      context '$or' do
+        let(:mql_operator) { '$or' }
+
+        it_behaves_like 'adds conditions to existing query with an extra $and'
+      end
+
+      context '$nor' do
+        let(:mql_operator) { '$nor' }
+
+        it_behaves_like 'adds conditions to existing query with an extra $and'
+      end
+
+      context '$not' do
+        let(:mql_operator) { '$not' }
+
+        it_behaves_like 'adds conditions to existing query'
+      end
+
+      context '$and' do
+        let(:mql_operator) { '$and' }
+
+        it_behaves_like 'adds conditions to existing query'
+      end
+    end
   end
 
   describe Symbol do

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

@@ -52,6 +52,22 @@ describe Mongoid::Criteria::Queryable::Storable do
         end
       end
 
+      context '$and to query with $and which already has the given key' do
+        let(:query) do
+          Mongoid::Query.new.where('$and' => [{foo: 'zoom'}])
+        end
+
+        let(:modified) do
+          query.send(query_method, '$and', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to existing $and' do
+          modified.selector.should == {
+            '$and' => [{'foo' => 'zoom'}, {'foo' => 'bar'}],
+          }
+        end
+      end
+
     end
 
     context '$or operator' do
@@ -74,9 +90,11 @@ describe Mongoid::Criteria::Queryable::Storable do
           query.send(query_method, '$or', [{'foo' => 'bar'}])
         end
 
-        it 'replaces top level' do
+        it 'adds the new conditions' do
           modified.selector.should == {
-            '$or' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+            'zoom' => 'zoom',
+            '$or' => ['foo' => 'bar'],
+          }
         end
       end
 
@@ -98,6 +116,66 @@ describe Mongoid::Criteria::Queryable::Storable do
     end
   end
 
+  describe '#add_field_expression' do
+    context 'simple field and value write' do
+      let(:modified) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      it 'adds the condition' do
+        modified.selector.should == {
+          'foo' => 'bar'
+        }
+      end
+    end
+
+    context 'an operator write' do
+      let(:modified) do
+        query.add_field_expression('$eq', {'foo' => 'bar'})
+      end
+
+      it 'is not allowed' do
+        lambda do
+          modified
+        end.should raise_error(ArgumentError, /Field cannot be an operator/)
+      end
+    end
+
+    context 'when another field exists in destination' do
+      let(:base) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      let(:modified) do
+        base.add_field_expression('zoom', 'zoom')
+      end
+
+      it 'adds the condition' do
+        modified.selector.should == {
+          'foo' => 'bar',
+          'zoom' => 'zoom',
+        }
+      end
+    end
+
+    context 'when field being added already exists in destination' do
+      let(:base) do
+        query.add_field_expression('foo', 'bar')
+      end
+
+      let(:modified) do
+        base.add_field_expression('foo', 'zoom')
+      end
+
+      it 'adds the new condition using $and' do
+        modified.selector.should == {
+          'foo' => 'bar',
+          '$and' => ['foo' => 'zoom'],
+        }
+      end
+    end
+  end
+
   describe '#add_operator_expression' do
     let(:query_method) { :add_operator_expression }
 

data/spec/mongoid/criteria_spec.rb

@@ -3428,6 +3428,38 @@ describe Mongoid::Criteria do
       Band.create(name: "Tool")
     end
 
+    context 'when provided no arguments' do
+      context 'on a model class' do
+        it 'returns an empty criteria' do
+          Band.where.selector.should == {}
+        end
+      end
+
+      context 'on an association' do
+        it 'returns an empty criteria' do
+          match.records.where.selector.should == {}
+        end
+      end
+    end
+
+    context 'when provided multiple arguments' do
+      context 'on a model class' do
+        it 'raises ArgumentError' do
+          lambda do
+            Band.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
+
+      context 'on an association' do
+        it 'raises ArgumentError' do
+          lambda do
+            match.records.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
+    end
+
     context "when provided a string" do
 
       context "when the criteria is embedded" do

data/spec/mongoid/persistable/pushable_spec.rb

@@ -7,7 +7,7 @@ describe Mongoid::Persistable::Pushable do
 
   describe "#add_to_set" do
 
-    context "when the document is a root document" do
+    context "when the document is a top level document" do
 
       shared_examples_for "a unique pushable root document" do
 
@@ -65,6 +65,60 @@ describe Mongoid::Persistable::Pushable do
 
         it_behaves_like "a unique pushable root document"
       end
+
+      context 'when the host model is not saved' do
+        context 'when attribute exists' do
+          let(:person) do
+            Person.new(aliases: [2])
+          end
+
+          it 'records the change' do
+            person.add_to_set({aliases: 1})
+
+            expect(person.aliases).to eq([2, 1])
+          end
+        end
+
+        context 'when attribute does not exist' do
+          let(:person) do
+            Person.new
+          end
+
+          it 'records the change' do
+            person.add_to_set({aliases: 1})
+
+            expect(person.aliases).to eq([1])
+          end
+        end
+      end
+
+      context 'when the host model is loaded from database' do
+        context 'when attribute exists' do
+          let(:person) do
+            Person.create!(aliases: [2])
+            person = Person.last
+          end
+
+          it 'records the change' do
+            person.add_to_set({aliases: 1})
+
+            expect(person.aliases).to eq([2, 1])
+          end
+        end
+
+        context 'when attribute does not exist' do
+          let(:person) do
+            Person.create!
+            person = Person.last
+          end
+
+          it 'records the change' do
+            person.add_to_set({aliases: 1})
+
+            expect(person.aliases).to eq([1])
+          end
+        end
+      end
     end
 
     context "when the document is embedded" do

data/spec/mongoid/serializable_spec.rb

@@ -16,31 +16,117 @@ describe Mongoid::Serializable do
     end
   end
 
-  describe ".include_root_in_json" do
+  %i(include_root_in_json include_root_in_json?).each do |meth|
+    describe ".#{meth}" do
 
-    let(:person) do
-      Person.new
-    end
+      before do
+        reload_model(:Minim)
+      end
 
-    context "when config set to true" do
+      after do
+        Mongoid.include_root_in_json = false
+        reload_model(:Minim)
+      end
 
-      before do
-        Mongoid.include_root_in_json = true
+      context "when global config is set to true" do
+
+        before do
+          Mongoid.include_root_in_json = true
+        end
+
+        it "returns true" do
+          expect(Minim.public_send(meth)).to be true
+        end
+
+        context 'when value is overridden to false in the model class' do
+          before do
+            Minim.include_root_in_json = false
+          end
+
+          it 'returns false' do
+            expect(Minim.public_send(meth)).to be false
+          end
+        end
       end
 
-      it "returns true" do
-        expect(person.include_root_in_json).to be true
+      context "when global config set to false" do
+
+        before do
+          Mongoid.include_root_in_json = false
+        end
+
+        it "returns false" do
+          expect(Minim.public_send(meth)).to be false
+        end
+
+        context 'when value is overridden to true in the model class' do
+          before do
+            Minim.include_root_in_json = true
+          end
+
+          it 'returns true' do
+            expect(Minim.public_send(meth)).to be true
+          end
+        end
       end
     end
 
-    context "when config set to false" do
+    describe "#include_root_in_json" do
 
       before do
+        reload_model(:Minim)
+      end
+
+      after do
         Mongoid.include_root_in_json = false
+        reload_model(:Minim)
+      end
+
+      let(:minim) do
+        Minim.new
+      end
+
+      context "when global config is set to true" do
+
+        before do
+          Minim.include_root_in_json.should be false
+          Mongoid.include_root_in_json = true
+        end
+
+        it "returns true" do
+          expect(minim.public_send(meth)).to be true
+        end
+
+        context 'when value is overridden to false in the model class' do
+          before do
+            Minim.include_root_in_json = false
+          end
+
+          it 'returns false' do
+            expect(minim.public_send(meth)).to be false
+          end
+        end
       end
 
-      it "returns false" do
-        expect(person.include_root_in_json).to be false
+      context "when global config set to false" do
+
+        before do
+          Mongoid.include_root_in_json = false
+        end
+
+        it "returns false" do
+          expect(minim.public_send(meth)).to be false
+        end
+
+        context 'when value is overridden to true in the model class' do
+          before do
+            Minim.include_root_in_json = true
+          end
+
+          it 'returns true' do
+            expect(minim.public_send(meth)).to be true
+          end
+        end
       end
     end
   end
@@ -773,32 +859,57 @@ describe Mongoid::Serializable do
 
   describe "#to_json" do
 
-    let(:person) do
-      Person.new
+    let(:account) do
+      Account.new
     end
 
-    context "when including root in json" do
+    context "when including root in json via Mongoid" do
 
       before do
+        account.include_root_in_json.should be false
         Mongoid.include_root_in_json = true
       end
 
+      after do
+        Mongoid.include_root_in_json = false
+      end
+
       it "uses the mongoid configuration" do
-        expect(person.to_json).to include("person")
+        expect(JSON.parse(account.to_json)).to have_key("account")
+      end
+    end
+
+    context "when including root in json via class" do
+
+      before do
+        account.include_root_in_json.should be false
+        Account.include_root_in_json = true
+      end
+
+      after do
+        Account.include_root_in_json = false
+      end
+
+      it "uses the class configuration" do
+        expect(JSON.parse(account.to_json)).to have_key("account")
       end
     end
 
     context "when not including root in json" do
 
       before do
-        Mongoid.include_root_in_json = false
+        account.include_root_in_json.should be false
       end
 
       it "uses the mongoid configuration" do
-        expect(person.to_json).to_not include("person")
+        expect(JSON.parse(account.to_json)).not_to have_key("account")
       end
     end
 
+    let(:person) do
+      Person.new
+    end
+
     context "when serializing a relation directly" do
 
       context "when serializing an embeds many" do