mongoid 5.4.0 → 6.4.8

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Queryable::Smash do
+
+  let(:smash) do
+    described_class.new(ns: :namespace)
+  end
+
+  describe "#[]" do
+
+    before do
+      smash.store(:namespace, :default)
+      smash.store(:some_field, 42)
+    end
+
+    context "when accessing aliased field" do
+
+      it "returns value for original field" do
+        expect(smash[:ns]).to eq(:default)
+      end
+    end
+
+    context "when accessing non-aliased field" do
+
+      it "returns value for the field" do
+        expect(smash[:some_field]).to eq(42)
+      end
+    end
+  end
+end

data/spec/mongoid/criteria/scopable_spec.rb

@@ -388,4 +388,85 @@ describe Mongoid::Criteria::Scopable do
       end
     end
   end
+
+  describe 'scope and where' do
+    class ScopeWhereModel
+      include Mongoid::Document
+
+      scope :foo, -> { where(foo: true) }
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['foo']).to eq(true)
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { ScopeWhereModel.foo.where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { ScopeWhereModel.where(hello: 'world').foo }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
+
+  describe 'scope with argument and where' do
+    class ArgumentScopeWhereModel
+      include Mongoid::Document
+
+      scope :my_text_search, ->(search) { where('$text' => {'$search' => search}) }
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { ArgumentScopeWhereModel.my_text_search('bar').where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { ArgumentScopeWhereModel.where(hello: 'world').my_text_search('bar') }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
+
+  describe 'built in text search scope and where' do
+    class TextSearchScopeWhereModel
+      include Mongoid::Document
+
+      # using the default text_search scope
+    end
+
+    shared_examples_for 'restricts to both' do
+      it 'restricts to both' do
+        expect(result.selector['$text']).to eq({'$search' => 'bar'})
+        expect(result.selector['hello']).to eq('world')
+      end
+    end
+
+    context 'scope is given first' do
+      let(:result) { TextSearchScopeWhereModel.text_search('bar').where(hello: 'world') }
+
+      it_behaves_like 'restricts to both'
+    end
+
+    context 'where is given first' do
+      let(:result) { TextSearchScopeWhereModel.where(hello: 'world').text_search('bar') }
+
+      it_behaves_like 'restricts to both'
+    end
+  end
 end

data/spec/mongoid/criteria_spec.rb

@@ -412,7 +412,7 @@ describe Mongoid::Criteria do
       end
 
       let(:criteria) do
-        Band.where(name: "Depeche Mode").asc(:name).includes(:records)
+        Band.where(name: "Depeche Mode").asc(:name).includes(:records).read(mode: :secondary)
       end
 
       before do
@@ -433,7 +433,7 @@ describe Mongoid::Criteria do
       end
 
       it "contains equal options" do
-        expect(clone.options).to eq({ sort: { "name" => 1 }})
+        expect(clone.options).to eq({ sort: { "name" => 1 }, read: { mode: :secondary } })
       end
 
       it "clones the options" do
@@ -467,6 +467,10 @@ describe Mongoid::Criteria do
       it "sets the context to nil" do
         expect(clone.instance_variable_get(:@context)).to be_nil
       end
+
+      it 'does not convert the option keys to string from symbols' do
+        expect(clone.options[:read][:mode]).to eq(:secondary)
+      end
     end
   end
 
@@ -590,7 +594,8 @@ describe Mongoid::Criteria do
 
     let!(:match) do
       Band.create(name: "Depeche Mode").tap do |band|
-        band.records.create(name: "101")
+        r = band.records
+        r.create(name: "101")
       end
     end
 
@@ -970,6 +975,7 @@ describe Mongoid::Criteria do
   end
 
   describe "#geo_near" do
+    max_server_version '4.0'
 
     before do
       Bar.create_indexes
@@ -2803,6 +2809,93 @@ describe Mongoid::Criteria do
         end
       end
     end
+
+    context 'when the field is localized' do
+
+      before do
+        I18n.locale = :en
+        d = Dictionary.create(description: 'english-text')
+        I18n.locale = :de
+        d.description = 'deutsch-text'
+        d.save
+      end
+
+      after do
+        I18n.locale = :en
+      end
+
+      context 'when entire field is included' do
+
+        let(:dictionary) do
+          Dictionary.only(:description).first
+
+        end
+
+        it 'loads all translations' do
+          expect(dictionary.description_translations.keys).to include('de', 'en')
+        end
+
+        it 'returns the field value for the current locale' do
+          I18n.locale = :en
+          expect(dictionary.description).to eq('english-text')
+          I18n.locale = :de
+          expect(dictionary.description).to eq('deutsch-text')
+        end
+      end
+
+      context 'when a specific locale is included' do
+
+        let(:dictionary) do
+          Dictionary.only(:'description.de').first
+        end
+
+        it 'loads translations only for the included locale' do
+          expect(dictionary.description_translations.keys).to include('de')
+          expect(dictionary.description_translations.keys).to_not include('en')
+        end
+
+        it 'returns the field value for the included locale' do
+          I18n.locale = :en
+          expect(dictionary.description).to be_nil
+          I18n.locale = :de
+          expect(dictionary.description).to eq('deutsch-text')
+        end
+      end
+
+      context 'when entire field is excluded' do
+
+        let(:dictionary) do
+          Dictionary.without(:description).first
+        end
+
+        it 'does not load all translations' do
+          expect(dictionary.description_translations.keys).to_not include('de', 'en')
+        end
+
+        it 'raises an ActiveModel::MissingAttributeError when attempting to access the field' do
+          expect{dictionary.description}.to raise_error ActiveModel::MissingAttributeError
+        end
+      end
+
+      context 'when a specific locale is excluded' do
+
+        let(:dictionary) do
+          Dictionary.without(:'description.de').first
+        end
+
+        it 'does not load excluded translations' do
+          expect(dictionary.description_translations.keys).to_not include('de')
+          expect(dictionary.description_translations.keys).to include('en')
+        end
+
+        it 'returns nil for excluded translations' do
+          I18n.locale = :en
+          expect(dictionary.description).to eq('english-text')
+          I18n.locale = :de
+          expect(dictionary.description).to be_nil
+        end
+      end
+    end
   end
 
   [ :or, :any_of ].each do |method|
@@ -2890,7 +2983,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the values" do
-          expect(plucked).to eq([ "Depeche Mode", "Tool", "Photek" ])
+          expect(plucked).to contain_exactly("Depeche Mode", "Tool", "Photek")
         end
 
         context "when subsequently executing the criteria without a pluck" do
@@ -2955,14 +3048,14 @@ describe Mongoid::Criteria do
         end
       end
 
-      context "when plucking mult-fields" do
+      context "when plucking multi-fields" do
 
         let(:plucked) do
           Band.where(:name.exists => true).pluck(:name, :likes)
         end
 
         it "returns the values" do
-          expect(plucked).to eq([ ["Depeche Mode", 3], ["Tool", 3], ["Photek", 1] ])
+          expect(plucked).to contain_exactly(["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
         end
       end
 
@@ -2973,7 +3066,7 @@ describe Mongoid::Criteria do
         end
 
         it "returns the duplicates" do
-          expect(plucked).to eq([ 3, 3, 1 ])
+          expect(plucked).to contain_exactly(3, 3, 1)
         end
       end
     end
@@ -3035,6 +3128,43 @@ describe Mongoid::Criteria do
         end
       end
     end
+
+    context 'when plucking a localized field' do
+
+      before do
+        I18n.locale = :en
+        d = Dictionary.create(description: 'english-text')
+        I18n.locale = :de
+        d.description = 'deutsch-text'
+        d.save
+      end
+
+      after do
+        I18n.locale = :en
+      end
+
+      context 'when plucking the entire field' do
+
+        let(:plucked) do
+          Dictionary.all.pluck(:description)
+        end
+
+        it 'returns all translations' do
+          expect(plucked.first).to eq({'en' => 'english-text', 'de' => 'deutsch-text'})
+        end
+      end
+
+      context 'when plucking a specific locale' do
+
+        let(:plucked) do
+          Dictionary.all.pluck(:'description.de')
+        end
+
+        it 'returns the specific translations' do
+          expect(plucked.first).to eq({'de' => 'deutsch-text'})
+        end
+      end
+    end
   end
 
   describe "#respond_to?" do
@@ -3192,6 +3322,8 @@ describe Mongoid::Criteria do
   end
 
   describe "#max_scan" do
+    max_server_version '4.0'
+
     let!(:band) do
       Band.create(name: "Depeche Mode")
     end
@@ -3314,17 +3446,6 @@ describe Mongoid::Criteria do
         end
       end
 
-      context 'when the criteria contains a BSON::Regexp::Raw' do
-
-        let(:criteria) do
-          Band.where(name: BSON::Regexp::Raw.new("^Depeche"))
-        end
-
-        it "returns the matching documents" do
-          expect(criteria).to eq([ match ])
-        end
-      end
-
       context "when the criteria is an exact fk array match" do
 
         let(:id_one) do
@@ -3347,7 +3468,7 @@ describe Mongoid::Criteria do
       context "when querying on a big decimal" do
 
         let(:sales) do
-          BigDecimal.new('0.1')
+          BigDecimal('0.1')
         end
 
         let!(:band) do
@@ -3502,8 +3623,21 @@ describe Mongoid::Criteria do
 
   describe "#with" do
 
-    let!(:criteria) do
-      Band.where(name: "Depeche Mode").with(collection: "artists")
+    let!(:criteria_and_collection) do
+      collection = nil
+      criteria = Band.where(name: "Depeche Mode").with(collection: "artists") do |crit|
+        collection = crit.collection
+        crit
+      end
+      [ criteria, collection ]
+    end
+
+    let(:criteria) do
+      criteria_and_collection[0]
+    end
+
+    let(:collection) do
+      criteria_and_collection[1]
     end
 
     it "retains the criteria selection" do
@@ -3511,7 +3645,7 @@ describe Mongoid::Criteria do
     end
 
     it "sets the persistence options" do
-      expect(criteria.persistence_options).to eq(collection: "artists")
+      expect(collection.name).to eq("artists")
     end
   end
 

data/spec/mongoid/document_spec.rb

@@ -10,10 +10,17 @@ describe Mongoid::Document do
     Person.new
   end
 
-  it "does not respond to _destroy" do
-    expect(person).to_not respond_to(:_destroy)
+  it "defines a _destroy method" do
+    expect(Person.new).to respond_to(:_destroy)
   end
 
+  describe "#_destroy" do
+  
+    it "default to false" do
+      expect(Person.new._destroy).to be false
+    end
+  end
+  
   describe ".included" do
 
     let(:models) do
@@ -122,75 +129,6 @@ describe Mongoid::Document do
     end
   end
 
-  describe "#cache_key" do
-
-    let(:document) do
-      Dokument.new
-    end
-
-    context "when the document is new" do
-
-      it "has a new key name" do
-        expect(document.cache_key).to eq("dokuments/new")
-      end
-    end
-
-    context "when persisted" do
-
-      before do
-        document.save
-      end
-
-      context "with updated_at" do
-
-        let!(:updated_at) do
-          document.updated_at.utc.to_s(:nsec)
-        end
-
-        it "has the id and updated_at key name" do
-          expect(document.cache_key).to eq("dokuments/#{document.id}-#{updated_at}")
-        end
-      end
-
-      context "without updated_at, with Timestamps" do
-
-        before do
-          document.updated_at = nil
-        end
-
-        it "has the id key name" do
-          expect(document.cache_key).to eq("dokuments/#{document.id}")
-        end
-      end
-    end
-
-    context "when model dont have Timestamps" do
-
-      let(:artist) do
-        Artist.create!
-      end
-
-      it "should have the id key name" do
-        expect(artist.cache_key).to eq("artists/#{artist.id}")
-      end
-    end
-
-    context "when model has Short Timestamps" do
-
-      let(:agent) do
-        ShortAgent.create!
-      end
-
-      let!(:updated_at) do
-        agent.updated_at.utc.to_s(:nsec)
-      end
-
-      it "has the id and updated_at key name" do
-        expect(agent.cache_key).to eq("short_agents/#{agent.id}-#{updated_at}")
-      end
-    end
-  end
-
   describe "#identity" do
 
     let(:person) do
@@ -495,6 +433,60 @@ describe Mongoid::Document do
         end
       end
     end
+
+    context ':compact option' do
+
+      before do
+        # These tests require a specific set of defined attributes
+        # on the model
+        expect(church.as_json.keys.sort).to eq(%w(_id location name))
+      end
+
+      context 'there is a nil valued attribute' do
+        let(:church) do
+          Church.create!(name: 'St. Basil')
+        end
+
+        it 'returns non-nil fields and _id only' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil')
+        end
+      end
+
+      context 'all attrbutes are nil valued' do
+        let(:church) do
+          Church.create!
+        end
+
+        it 'returns a hash with _id only' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id)
+        end
+      end
+
+      context 'there are no nil valued attributes' do
+        let(:church) do
+          Church.create!(name: 'St. Basil', location: {})
+        end
+
+        it 'returns all fields and _id' do
+          actual = church.as_json(compact: true)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil',
+            'location' => {})
+        end
+      end
+
+      context 'when option is specified as a truthy value' do
+        let(:church) do
+          Church.create!(name: 'St. Basil')
+        end
+
+        it 'returns non-nil fields and _id only' do
+          actual = church.as_json(compact: 1)
+          expect(actual).to eq('_id' => church.id, 'name' => 'St. Basil')
+        end
+      end
+    end
   end
 
   describe "#as_document" do
@@ -519,14 +511,26 @@ describe Mongoid::Document do
       expect(person.as_document).to have_key("name")
     end
 
+    it "includes embeds one attributes as a symbol" do
+      expect(person.as_document).to have_key(:name)
+    end
+
     it "includes embeds many attributes" do
       expect(person.as_document).to have_key("addresses")
     end
 
+    it "includes embeds many attributes as a symbol" do
+      expect(person.as_document).to have_key(:addresses)
+    end
+
     it "includes second level embeds many attributes" do
       expect(person.as_document["addresses"].first).to have_key("locations")
     end
 
+    it "includes second level embeds many attributes as a symbol" do
+      expect(person.as_document["addresses"].first).to have_key(:locations)
+    end
+
     context "with relation define store_as option in embeded_many" do
 
       let!(:phone) do
@@ -537,6 +541,10 @@ describe Mongoid::Document do
         expect(person.as_document).to have_key("mobile_phones")
       end
 
+      it 'includes the store_as key association as a symbol' do
+        expect(person.as_document).to have_key(:mobile_phones)
+      end
+
       it 'should not include the key of association' do
         expect(person.as_document).to_not have_key("phones")
       end
@@ -675,7 +683,7 @@ describe Mongoid::Document do
 
         it "freezes attributes" do
           expect(person.freeze).to eq(person)
-          expect { person.title = "something" }.to raise_error
+          expect { person.title = "something" }.to raise_error(RuntimeError)
         end
       end
 
@@ -689,7 +697,7 @@ describe Mongoid::Document do
           person.freeze
           expect {
             person.title = "something"
-          }.to raise_error
+          }.to raise_error(RuntimeError)
         end
       end
     end
@@ -1215,22 +1223,20 @@ describe Mongoid::Document do
 
   context "when marshalling the document" do
 
-    let(:person) do
-      Person.new.tap do |person|
-        person.addresses.extension
-      end
+    let(:agency) do
+      Agency.new
     end
 
-    let!(:account) do
-      person.create_account(name: "savings")
+    let!(:agent) do
+      agency.agents.build(title: "VIP")
     end
 
     describe Marshal, ".dump" do
 
       it "successfully dumps the document" do
         expect {
-          Marshal.dump(person)
-          Marshal.dump(account)
+          Marshal.dump(agency)
+          Marshal.dump(agent)
         }.not_to raise_error
       end
     end
@@ -1238,7 +1244,7 @@ describe Mongoid::Document do
     describe Marshal, ".load" do
 
       it "successfully loads the document" do
-        expect { Marshal.load(Marshal.dump(person)) }.not_to raise_error
+        expect(Marshal.load(Marshal.dump(agency))).to eq(agency)
       end
     end
   end
@@ -1253,22 +1259,26 @@ describe Mongoid::Document do
 
       describe "#fetch" do
 
-        let!(:person) do
-          Person.new
+        let(:agency) do
+          Agency.new
+        end
+
+        let(:agent) do
+          agency.agents.build(title: "VIP", address: address)
         end
 
-        let!(:account) do
-          person.create_account(name: "savings")
+        let(:address) do
+          Address.new(city: 'Berlin')
         end
 
         it "stores the parent object" do
-          expect(cache.fetch("key") { person }).to eq(person)
-          expect(cache.fetch("key")).to eq(person)
+          expect(cache.fetch("key") { agency }).to eq(agency)
+          expect(cache.fetch("key")).to eq(agency)
         end
 
         it "stores the embedded object" do
-          expect(cache.fetch("key") { account }).to eq(account)
-          expect(cache.fetch("key")).to eq(account)
+          expect(cache.fetch("key") { agent }).to eq(agent)
+          expect(cache.fetch("key").address).to eq(agent.address)
         end
       end
     end