mongoid 7.0.5 → 7.0.6

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/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/matchable/default_spec.rb

@@ -112,14 +112,21 @@ describe Mongoid::Matchable::Default do
         described_class.new(["Test1", "Test2", "Test3"])
       end
 
-      context "when the attribute contains the value" do
+      context "when the attribute equals the value" do
 
         it "returns true" do
           expect(matcher._matches?(["Test1", "Test2", "Test3"])).to be true
         end
       end
 
-      context "when the attribute does not contain the value" do
+      context "when the value contains same items as attribute but in different order" do
+
+        it "returns false" do
+          expect(matcher._matches?(["Test1", "Test3", "Test2"])).to be false
+        end
+      end
+
+      context "when the value is a subset of attribute" do
 
         it "returns false" do
           expect(matcher._matches?(["Test1", "Test2"])).to be false

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -796,20 +796,47 @@ describe Mongoid::Validatable::UniquenessValidator do
           end
         end
 
-        context "when a range scope is provided" do
+        context "when a range condition is provided" do
 
           before do
-            Dictionary.validates_uniqueness_of(:name, :scope => Dictionary.where(:year.gte => 1900, :year.lt => 2000))
-            Dictionary.create(name: "French-English", year: 1950)
-            Dictionary.create(name: "French-English", year: 1960)
+            Dictionary.validates_uniqueness_of(:name,
+              conditions: -> { Dictionary.where(:year.gte => 1900, :year.lt => 2000) })
           end
 
           after do
             Dictionary.reset_callbacks(:validate)
           end
 
-          it "successfully prevents uniqueness violation" do
-            expect(Dictionary.all.size).to eq(1)
+          context 'when multiple documents would match the condition' do
+            it "prevents creation of new document" do
+              Dictionary.create!(name: "French-English", year: 1950)
+
+              expect do
+                Dictionary.create!(name: "French-English", year: 1960)
+              end.to raise_error(Mongoid::Errors::Validations, /Name is already taken/)
+
+              expect(Dictionary.all.size).to eq(1)
+            end
+          end
+
+          context 'when only new document would match the condition' do
+            it 'creates the new document' do
+              Dictionary.create!(name: "French-English", year: 950)
+              expect do
+                Dictionary.create!(name: "French-English", year: 1950)
+              end.not_to raise_error
+            end
+          end
+
+          context 'when only existing document matches the condition' do
+            it 'creates the new document' do
+              pending 'https://jira.mongodb.org/browse/MONGOID-4815'
+
+              Dictionary.create!(name: "French-English", year: 1950)
+              expect do
+                Dictionary.create!(name: "French-English", year: 950)
+              end.not_to raise_error
+            end
           end
         end
 

data/spec/support/expectations.rb

@@ -1,10 +1,24 @@
 module Mongoid
   module Expectations
 
+    def connection_class
+      if defined?(Mongo::Server::ConnectionBase)
+        Mongo::Server::ConnectionBase
+      else
+        # Pre-2.8 drivers
+        Mongo::Server::Connection
+      end
+    end
+
     def expect_query(number)
-      # There are both start and complete events for each query.
-      expect(Mongo::Logger.logger).to receive(:debug?).exactly(number * 2).times.and_call_original
-      yield
+      RSpec::Mocks.with_temporary_scope do
+        if number > 0
+          expect_any_instance_of(connection_class).to receive(:command_started).exactly(number).times.and_call_original
+        else
+          expect_any_instance_of(connection_class).not_to receive(:command_started)
+        end
+        yield
+      end
     end
 
     def expect_no_queries(&block)