mongoid 7.0.3 → 7.0.8

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

@@ -990,6 +990,7 @@ describe Mongoid::Criteria do
   end
 
   describe "#geo_near" do
+    max_server_version '4.0'
 
     before do
       Bar.create_indexes
@@ -2333,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 }}
         ])
@@ -3336,6 +3337,8 @@ describe Mongoid::Criteria do
   end
 
   describe "#max_scan" do
+    max_server_version '4.0'
+
     let!(:band) do
       Band.create(name: "Depeche Mode")
     end
@@ -3496,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")
@@ -3550,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