mongoid 7.0.6 → 7.1.2

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Criteria::Queryable::Selector do

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Criteria::Queryable::Smash do

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Criteria::Queryable::Storable do
+
+  let(:query) do
+    Mongoid::Query.new
+  end
+
+  shared_examples_for 'logical operator expressions' do
+
+    context '$and operator' do
+      context '$and to empty query' do
+        let(:modified) do
+          query.send(query_method, '$and', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to top level' do
+          modified.selector.should == {'$and' => [{'foo' => 'bar'}]}
+        end
+      end
+
+      context '$and to query with other keys' do
+        let(:query) do
+          Mongoid::Query.new.where(zoom: 'zoom')
+        end
+
+        let(:modified) do
+          query.send(query_method, '$and', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to top level' do
+          modified.selector.should == {'zoom' => 'zoom',
+            '$and' => [{'foo' => 'bar'}]}
+        end
+      end
+
+      context '$and to query with $and' do
+        let(:query) do
+          Mongoid::Query.new.where('$and' => [{zoom: 'zoom'}])
+        end
+
+        let(:modified) do
+          query.send(query_method, '$and', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to existing $and' do
+          modified.selector.should == {
+            '$and' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+        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
+      context '$or to empty query' do
+        let(:modified) do
+          query.send(query_method, '$or', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to top level' do
+          modified.selector.should == {'$or' => [{'foo' => 'bar'}]}
+        end
+      end
+
+      context '$or to query with other keys' do
+        let(:query) do
+          Mongoid::Query.new.where(zoom: 'zoom')
+        end
+
+        let(:modified) do
+          query.send(query_method, '$or', [{'foo' => 'bar'}])
+        end
+
+        it 'adds the new conditions' do
+          modified.selector.should == {
+            'zoom' => 'zoom',
+            '$or' => ['foo' => 'bar'],
+          }
+        end
+      end
+
+      context '$or to query with $or' do
+        let(:query) do
+          Mongoid::Query.new.where('$or' => [{zoom: 'zoom'}])
+        end
+
+        let(:modified) do
+          query.send(query_method, '$or', [{'foo' => 'bar'}])
+        end
+
+        it 'adds to existing $or' do
+          modified.selector.should == {
+            '$or' => [{'zoom' => 'zoom'}, {'foo' => 'bar'}]}
+        end
+      end
+
+    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 }
+
+    it_behaves_like 'logical operator expressions'
+  end
+
+  describe '#add_logical_operator_expression' do
+    let(:query_method) { :add_logical_operator_expression }
+
+    it_behaves_like 'logical operator expressions'
+  end
+end

data/spec/mongoid/criteria/scopable_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Criteria::Scopable do

data/spec/mongoid/criteria_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Criteria do
@@ -2334,7 +2337,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 }}
         ])
@@ -3425,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
@@ -3499,7 +3534,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")
@@ -3533,6 +3569,40 @@ describe Mongoid::Criteria do
         end
       end
     end
+
+    context 'when given multiple keys in separate calls' do
+      let(:criteria) { Band.where(foo: 1).where(bar: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq('foo' => 1, 'bar' => 2)
+      end
+    end
+
+    context 'when given same key in separate calls' do
+      let(:criteria) { Band.where(foo: 1).where(foo: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq('foo' => 1, '$and' => [{'foo' => 2}])
+      end
+    end
+
+    context 'when given same key in separate calls and there are other criteria' do
+      let(:criteria) { Band.where(foo: 1, bar: 3).where(foo: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq(
+          'foo' => 1, '$and' => [{'foo' => 2}], 'bar' => 3)
+      end
+    end
+
+    context 'when given same key in separate calls and other criteria are added later' do
+      let(:criteria) { Band.where(foo: 1).where(foo: 2).where(bar: 3) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq(
+          'foo' => 1, '$and' => [{'foo' => 2}], 'bar' => 3)
+      end
+    end
   end
 
   describe "#for_js" do
@@ -3553,6 +3623,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_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_query_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Document do
+
+  context 'when projecting with #only' do
+    before do
+      Person.create!(username: 'Dev', title: 'CEO')
+    end
+
+    let(:person) { Person.where(username: 'Dev').only(:_id, :username).first }
+
+    it 'populates specified fields only' do
+      expect do
+        person.title
+      end.to raise_error(ActiveModel::MissingAttributeError)
+      # has a default value specified in the model
+      expect do
+        person.age
+      end.to raise_error(ActiveModel::MissingAttributeError)
+      expect(person.attributes.keys).to eq(['_id', 'username'])
+    end
+
+    it 'allows writing omitted fields' do
+      pending 'https://jira.mongodb.org/browse/MONGOID-4701'
+
+      expect do
+        person.age
+      end.to raise_error(ActiveModel::MissingAttributeError)
+      person.age = 42
+      expect(person.age).to be 42
+      person.save!
+      _person = Person.find(person.id)
+      expect(_person.age).to be 42
+    end
+  end
+end

data/spec/mongoid/document_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Document do

data/spec/mongoid/equality_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # -*- coding: utf-8 -*-
 require "spec_helper"
 

data/spec/mongoid/errors/ambiguous_relationship_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongoid::Errors::AmbiguousRelationship do
@@ -10,19 +13,19 @@ describe Mongoid::Errors::AmbiguousRelationship do
 
     it "contains the problem in the message" do
       expect(error.message).to include(
-        "Ambiguous relations :drugs, :evil_drugs defined on Person."
+        "Ambiguous associations :drugs, :evil_drugs defined on Person."
       )
     end
 
     it "contains the summary in the message" do
       expect(error.message).to include(
-        "When Mongoid attempts to set an inverse document of a relation in memory"
+        "When Mongoid attempts to set an inverse document of an association in memory"
       )
     end
 
     it "contains the resolution in the message" do
       expect(error.message).to include(
-        "On the :person relation on Drug you must add an :inverse_of option"
+        "On the :person association on Drug you must add an :inverse_of option"
       )
     end
   end

data/spec/mongoid/errors/callback_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
 describe Mongoid::Errors::Callback do