mongoid 6.4.8 → 7.0.13

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

@@ -1079,7 +1079,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
               :location.within_box => [[ 1, 10 ], [ 2, 10 ]]
             )
           end
-  
+
           it "adds the $geoIntersects expression" do
             expect(selection.selector).to eq({
               "location" => {
@@ -2428,7 +2428,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
       end
     end
 
-    context "when chaninning the criterion" do
+    context "when chaining the criterion" do
 
       context "when the criterion are for different fields" do
 
@@ -2665,225 +2665,6 @@ describe Mongoid::Criteria::Queryable::Selectable do
     end
   end
 
-  describe "#not" do
-
-    context "when provided no criterion" do
-
-      let(:selection) do
-        query.not
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a non cloned query" do
-        expect(selection).to equal(query)
-      end
-
-      context "when the following criteria is a query method" do
-
-        let(:selection) do
-          query.not.all(field: [ 1, 2 ])
-        end
-
-        it "negates the all selection" do
-          expect(selection.selector).to eq(
-            { "field" => { "$not" => { "$all" => [ 1, 2 ] }}}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
-        end
-      end
-
-      context "when the following criteria is a gt method" do
-
-        let(:selection) do
-          query.not.gt(age: 50)
-        end
-
-        it "negates the gt selection" do
-          expect(selection.selector).to eq(
-            { "age" => { "$not" => { "$gt" => 50 }}}
-          )
-        end
-
-        it "returns a coned query" do
-          expect(selection).to_not eq(query)
-        end
-
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
-        end
-      end
-
-      context "when the following criteria is a where" do
-
-        let(:selection) do
-          query.not.where(field: 1, :other.in => [ 1, 2 ])
-        end
-
-        it "negates the selection with an operator" do
-          expect(selection.selector).to eq(
-            { "field" => { "$ne" => 1 }, "other" => { "$not" => { "$in" => [ 1, 2 ] }}}
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
-        end
-      end
-
-      context "when the following criteria is a where with a regexp" do
-
-        let(:selection) do
-          query.not.where(field: 1, other: /test/)
-        end
-
-        it "negates the selection with an operator" do
-          expect(selection.selector).to eq(
-            { "field" => { "$ne" => 1 }, "other" => { "$not" => /test/ } }
-          )
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-
-        it "removes the negation on the clone" do
-          expect(selection).to_not be_negating
-        end
-
-      end
-    end
-
-    context "when provided nil" do
-
-      let(:selection) do
-        query.not(nil)
-      end
-
-      it "does not add any criterion" do
-        expect(selection.selector).to eq({})
-      end
-
-      it "returns the query" do
-        expect(selection).to eq(query)
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided a single criterion" do
-
-      let(:selection) do
-        query.not(field: /test/)
-      end
-
-      it "adds the $not selector" do
-        expect(selection.selector).to eq({
-          "field" => { "$not" => /test/ }
-        })
-      end
-
-      it "returns a cloned query" do
-        expect(selection).to_not equal(query)
-      end
-    end
-
-    context "when provided multiple criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.not(first: /1/, second: /2/)
-        end
-
-        it "adds the $not selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$not" => /1/ },
-            "second" => { "$not" => /2/ }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-
-    context "when chaining the criterion" do
-
-      context "when the criterion are for different fields" do
-
-        let(:selection) do
-          query.not(first: /1/).not(second: /2/)
-        end
-
-        it "adds the $not selectors" do
-          expect(selection.selector).to eq({
-            "first" => { "$not" => /1/ },
-            "second" => { "$not" => /2/ }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are on the same field" do
-
-        let(:selection) do
-          query.not(first: /1/).not(first: /2/)
-        end
-
-        it "overwrites the first $not selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$not" => /2/ }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-
-      context "when the criterion are a double negative" do
-
-        let(:selection) do
-          query.not.where(:first.not => /1/)
-        end
-
-        it "does not double the $not selector" do
-          expect(selection.selector).to eq({
-            "first" =>  { "$not" => /1/ }
-          })
-        end
-
-        it "returns a cloned query" do
-          expect(selection).to_not equal(query)
-        end
-      end
-    end
-  end
-
   describe "#or" do
 
     context "when provided no criterion" do
@@ -4198,7 +3979,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context "when using the strategies via methods" do
 
-      context "when the values are a hash" do
+      context "when different operators are specified" do
 
         let(:selection) do
           query.gt(field: 5).lt(field: 10).ne(field: 7)
@@ -4211,7 +3992,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
 
-      context "when the values are not hashes" do
+      context "when the same operator is specified" do
 
         let(:selection) do
           query.where(field: 5).where(field: 10)
@@ -4225,7 +4006,7 @@ describe Mongoid::Criteria::Queryable::Selectable do
 
     context "when using the strategies via #where" do
 
-      context "when the values are a hash" do
+      context "when using complex keys with different operators" do
 
         let(:selection) do
           query.where(:field.gt => 5, :field.lt => 10, :field.ne => 7)

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

@@ -841,4 +841,41 @@ describe Mongoid::Criteria::Queryable::Selector do
       end
     end
   end
+
+  describe '#multi_selection?' do
+
+    let(:selector) do
+      described_class.new
+    end
+
+    context 'when key is $and' do
+      it 'returns true' do
+        expect(selector.send(:multi_selection?, '$and')).to be true
+      end
+    end
+
+    context 'when key is $or' do
+      it 'returns true' do
+        expect(selector.send(:multi_selection?, '$or')).to be true
+      end
+    end
+
+    context 'when key is $nor' do
+      it 'returns true' do
+        expect(selector.send(:multi_selection?, '$nor')).to be true
+      end
+    end
+
+    context 'when key includes $or but is not $or' do
+      it 'returns false' do
+        expect(selector.send(:multi_selection?, '$ore')).to be false
+      end
+    end
+
+    context 'when key is some other ey' do
+      it 'returns false' do
+        expect(selector.send(:multi_selection?, 'foo')).to be false
+      end
+    end
+  end
 end

data/spec/mongoid/criteria_spec.rb

@@ -285,8 +285,23 @@ describe Mongoid::Criteria do
       Band.where(name: "Depeche Mode")
     end
 
-    it "returns the criteria as a json hash" do
-      expect(criteria.as_json).to eq([ band.serializable_hash ])
+    # as_json changed in rails 6 to call as_json on serializable_hash.
+    # https://github.com/rails/rails/commit/2e5cb980a448e7f4ab00df6e9ad4c1cc456616aa
+
+    context 'rails < 6' do
+      max_rails_version '5.2'
+
+      it "returns the criteria as a json hash" do
+        expect(criteria.as_json).to eq([ band.serializable_hash ])
+      end
+    end
+
+    context 'rails >= 6' do
+      min_rails_version '6.0'
+
+      it "returns the criteria as a json hash" do
+        expect(criteria.as_json).to eq([ band.serializable_hash.as_json ])
+      end
     end
   end
 
@@ -1445,18 +1460,18 @@ describe Mongoid::Criteria do
       end
     end
 
-    context "when including the same metadata multiple times" do
+    context "when including the same association multiple times" do
 
       let(:criteria) do
         Person.all.includes(:posts, :posts).includes(:posts)
       end
 
-      let(:metadata) do
+      let(:association) do
         Person.reflect_on_association(:posts)
       end
 
-      it "does not duplicate the metadata in the inclusions" do
-        expect(criteria.inclusions).to eq([ metadata ])
+      it "does not duplicate the association in the inclusions" do
+        expect(criteria.inclusions).to eq([ association ])
       end
     end
 
@@ -2218,12 +2233,12 @@ describe Mongoid::Criteria do
       Band.includes(:records)
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
     it "returns the inclusions" do
-      expect(criteria.inclusions).to eq([ metadata ])
+      expect(criteria.inclusions).to eq([ association ])
     end
   end
 
@@ -2233,16 +2248,16 @@ describe Mongoid::Criteria do
       Band.all
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
     before do
-      criteria.inclusions = [ metadata ]
+      criteria.inclusions = [ association ]
     end
 
     it "sets the inclusions" do
-      expect(criteria.inclusions).to eq([ metadata ])
+      expect(criteria.inclusions).to eq([ association ])
     end
   end
 
@@ -2319,7 +2334,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the map/reduce results" do
-        expect(map_reduce).to eq([
+        expect(map_reduce.sort_by { |doc| doc['_id'] }).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
@@ -2410,7 +2425,7 @@ describe Mongoid::Criteria do
         end
       end
 
-      let(:metadata) do
+      let(:association) do
         Band.relations["records"]
       end
 
@@ -2435,7 +2450,7 @@ describe Mongoid::Criteria do
       end
 
       it "merges the inclusions" do
-        expect(merged.inclusions).to eq([ metadata ])
+        expect(merged.inclusions).to eq([ association ])
       end
 
       it "returns a new criteria" do
@@ -2449,7 +2464,7 @@ describe Mongoid::Criteria do
         { klass: Band, includes: [ :records ] }
       end
 
-      let(:metadata) do
+      let(:association) do
         Band.relations["records"]
       end
 
@@ -2470,7 +2485,7 @@ describe Mongoid::Criteria do
       end
 
       it "merges the inclusions" do
-        expect(merged.inclusions).to eq([ metadata ])
+        expect(merged.inclusions).to eq([ association ])
       end
 
       it "returns a new criteria" do
@@ -2495,7 +2510,7 @@ describe Mongoid::Criteria do
       end
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
@@ -2520,7 +2535,7 @@ describe Mongoid::Criteria do
     end
 
     it "merges the inclusions" do
-      expect(merged.inclusions).to eq([ metadata ])
+      expect(merged.inclusions).to eq([ association ])
     end
 
     it "returns the same criteria" do
@@ -3484,7 +3499,8 @@ describe Mongoid::Criteria do
         end
       end
 
-      context "when querying on a BSON::Decimal128", if: decimal128_supported? do
+      context "when querying on a BSON::Decimal128" do
+        min_server_version '3.4'
 
         let(:decimal) do
           BSON::Decimal128.new("0.0005")
@@ -3538,6 +3554,7 @@ describe Mongoid::Criteria do
     end
 
     context "when the code has scope" do
+      max_server_version '4.2'
 
       let(:criteria) do
         Band.for_js("this.name == param", param: "Depeche Mode")

data/spec/mongoid/document_fields_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Document do
+
+  describe 'BSON::Binary field' do
+    context 'when assigned a BSON::Binary instance' do
+      let(:data) do
+        BSON::Binary.new("hello world")
+      end
+
+      let(:registry) do
+        Registry.new(data: data)
+      end
+
+      it 'does not freeze the specified data' do
+        registry
+
+        data.should_not be_frozen
+      end
+
+      it 'persists' do
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.data.should == data
+      end
+    end
+
+    context 'when assigned a binary string' do
+      let(:data) do
+        # Frozen string literals do not allow setting encoding on a string
+        # literal - work around by composing the string at runtime
+        ([0, 253, 254] * 2).map(&:chr).join.force_encoding('BINARY')
+      end
+
+      let(:registry) do
+        Registry.new(data: data)
+      end
+
+      it 'assigns as a BSON::Binary object' do
+        pending 'https://jira.mongodb.org/browse/MONGOID-4823'
+
+        registry.data.should be_a(BSON::Binary)
+      end
+
+      it 'persists' do
+        pending 'https://jira.mongodb.org/browse/MONGOID-4823'
+
+        registry.save!
+
+        _registry = Registry.find(registry.id)
+        _registry.data.should == BSON::Binary.new(data)
+      end
+    end
+  end
+
+  describe 'Hash field' do
+    context 'with symbol key and value' do
+      let(:church) do
+        Church.create!(location: {state: :ny})
+      end
+
+      let(:found_church) do
+        Church.find(church.id)
+      end
+
+      it 'round-trips the value' do
+        found_church.location[:state].should == :ny
+      end
+
+      it 'stringifies the key' do
+        found_church.location.keys.should == %w(state)
+      end
+
+      it 'retrieves value as symbol via driver' do
+        Church.delete_all
+
+        church
+
+        v = Church.collection.find.first
+        v['location'].should == {'state' => :ny}
+      end
+    end
+  end
+end

data/spec/mongoid/document_persistence_context_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Document do
+
+  let(:klass) do
+    Person
+  end
+
+  let(:person) do
+    Person.new
+  end
+
+  describe '.client_name' do
+    it 'returns client name' do
+      Person.client_name.should == :default
+    end
+  end
+
+  describe '.database_name' do
+    it 'returns database name' do
+      Person.database_name.should == 'mongoid_test'
+    end
+  end
+
+  describe '.collection_name' do
+    it 'returns collection name' do
+      Person.collection_name.should == :people
+    end
+  end
+end

data/spec/mongoid/document_spec.rb

@@ -15,12 +15,12 @@ describe Mongoid::Document do
   end
 
   describe "#_destroy" do
-  
+
     it "default to false" do
       expect(Person.new._destroy).to be false
     end
   end
-  
+
   describe ".included" do
 
     let(:models) do
@@ -94,11 +94,11 @@ describe Mongoid::Document do
     context "when the document is not subclassed" do
 
       let(:types) do
-        Address._types
+        Kangaroo._types
       end
 
       it "returns the document" do
-        expect(types).to eq([ "Address" ])
+        expect(types).to eq([ "Kangaroo" ])
       end
     end
 
@@ -385,6 +385,27 @@ describe Mongoid::Document do
       Person.new(title: "Sir")
     end
 
+    describe 'id' do
+      context 'rails < 6' do
+        max_rails_version '5.2'
+
+        it 'is a BSON::ObjectId' do
+          id = person.as_json['_id']
+          expect(id).to be_a(BSON::ObjectId)
+        end
+      end
+
+      context 'rails >= 6' do
+        min_rails_version '6.0'
+
+        it 'is a hash with $oid' do
+          id = person.as_json['_id']
+          expect(id).to be_a(Hash)
+          expect(id['$oid']).to be_a(String)
+        end
+      end
+    end
+
     context "when no options are provided" do
 
       it "does not apply any options" do
@@ -435,6 +456,10 @@ describe Mongoid::Document do
     end
 
     context ':compact option' do
+      # Since rails 6 differs in how it treats id fields,
+      # run this test on one version of rails. Currently rails 6 is in beta,
+      # when it is released this version should be changed to 6.
+      max_rails_version '5.2'
 
       before do
         # These tests require a specific set of defined attributes