mongoid 5.1.5 → 5.2.0

data/spec/mongoid/criteria_spec.rb

@@ -3078,14 +3078,14 @@ describe Mongoid::Criteria do
       context "when not including private methods" do
 
         it "returns false" do
-          expect(criteria).to_not respond_to(:fork)
+          expect(criteria).to_not respond_to(:initialize_copy)
         end
       end
 
       context "when including private methods" do
 
         it "returns true" do
-          expect(criteria.respond_to?(:fork, true)).to be true
+          expect(criteria.respond_to?(:initialize_copy, true)).to be true
         end
       end
     end
@@ -3352,6 +3352,25 @@ describe Mongoid::Criteria do
         end
       end
 
+      context "when querying on a BSON::Decimal128", if: decimal128_supported? do
+
+        let(:decimal) do
+          BSON::Decimal128.new("0.0005")
+        end
+
+        let!(:band) do
+          Band.create(name: "Boards of Canada", decimal: decimal)
+        end
+
+        let(:from_db) do
+          Band.where(decimal: decimal).first
+        end
+
+        it "finds the document by the big decimal value" do
+          expect(from_db).to eq(band)
+        end
+      end
+
       context 'when querying on a polymorphic relation' do
 
         let(:movie) do

data/spec/mongoid/extensions/decimal128_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Mongoid::Extensions::Decimal128 do
+
+  let(:decimal128) do
+    BSON::Decimal128.new("0.0005")
+  end
+
+  describe "#__evolve_decimal128__" do
+
+    it "returns the same instance" do
+      expect(decimal128.__evolve_decimal128__).to be(decimal128)
+    end
+  end
+
+  describe ".evolve" do
+
+    context "when provided a single decimal128" do
+
+      let(:evolved) do
+        BSON::Decimal128.evolve(decimal128)
+      end
+
+      it "returns the decimal128" do
+        expect(evolved).to be(decimal128)
+      end
+    end
+
+    context "when provided an array of decimal128s" do
+
+      let(:other_decimal128) do
+        BSON::Decimal128.new("3.14")
+      end
+
+      let(:evolved) do
+        BSON::ObjectId.evolve([decimal128, other_decimal128])
+      end
+
+      it "returns the array of decimal128s" do
+        expect(evolved).to eq([decimal128, other_decimal128])
+      end
+    end
+  end
+end

data/spec/mongoid/extensions/time_spec.rb

@@ -281,7 +281,7 @@ describe Mongoid::Extensions::Time do
       end
 
       it "does not alter seconds with fractions" do
-        expect(DateTime.mongoize(11.11).to_f).to eq(11.11)
+        expect(DateTime.mongoize(1.11).to_f).to eq(1.11)
       end
 
       context "when using the ActiveSupport time zone" do
@@ -344,7 +344,7 @@ describe Mongoid::Extensions::Time do
       end
 
       it "does not alter seconds with fractions" do
-        expect(Time.mongoize(102.63).to_f).to eq(102.63)
+        expect(Time.mongoize(102.25).to_f).to eq(102.25)
       end
     end
 

data/spec/mongoid/fields/localized_spec.rb

@@ -430,6 +430,97 @@ describe Mongoid::Fields::Localized do
           expect(value).to eq({ "de" => 100 })
         end
       end
+
+      context 'when the type is Boolean' do
+
+        before do
+          I18n.enforce_available_locales = false
+          ::I18n.locale = :de
+        end
+
+        after do
+          ::I18n.locale = :en
+        end
+
+        context "when the value is false" do
+
+          let(:field) do
+            described_class.new(:boolean_value, localize: true, type: Boolean)
+          end
+
+          let(:value) do
+            field.demongoize({ "de" => false })
+          end
+
+          it "returns the boolean value from the set locale" do
+            expect(value).to eq(false)
+          end
+        end
+
+        context "when the value is true" do
+
+          let(:field) do
+            described_class.new(:boolean_value, localize: true, type: Boolean)
+          end
+
+          let(:value) do
+            field.demongoize({"de" => true})
+          end
+
+          it "returns the boolean value from the set locale" do
+            expect(value).to eq(true)
+          end
+        end
+
+        context "when fallbacks are defined" do
+
+          before(:all) do
+            require "i18n/backend/fallbacks"
+            I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+          end
+
+          context "when the lookup does not need to use fallbacks" do
+
+            context "when the value is false" do
+
+              before do
+                ::I18n.fallbacks[:de] = [:en, :es]
+              end
+
+              let(:field) do
+                described_class.new(:boolean_value, localize: true, type: Boolean)
+              end
+
+              let(:value) do
+                field.demongoize({"de" => false})
+              end
+
+              it "returns the boolean value from the set locale" do
+                expect(value).to eq(false)
+              end
+            end
+
+            context "when the value is true" do
+
+              before do
+                ::I18n.fallbacks[:de] = [:en, :es]
+              end
+
+              let(:field) do
+                described_class.new(:boolean_value, localize: true, type: Boolean)
+              end
+
+              let(:value) do
+                field.demongoize({"de" => true})
+              end
+
+              it "returns the boolean value from the set locale" do
+                expect(value).to eq(true)
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/mongoid/indexable_spec.rb

@@ -114,6 +114,34 @@ describe Mongoid::Indexable do
         expect(indexes.get(_type: 1)).to_not be_nil
       end
     end
+
+    context "when a collation option is specified", if: collation_supported? do
+
+      let(:klass) do
+        Class.new do
+          include Mongoid::Document
+          store_in collection: "test_db_indexes"
+          index({name: 1}, {collation: {locale: 'en_US', strength: 2}})
+        end
+      end
+
+      before do
+        klass.create_indexes
+      end
+
+      after do
+        klass.remove_indexes
+      end
+
+      let(:indexes) do
+        klass.collection.indexes
+      end
+
+      it "creates the indexes" do
+        expect(indexes.get("name_1")["collation"]).to_not be_nil
+        expect(indexes.get("name_1")["collation"]["locale"]).to eq('en_US')
+      end
+    end
   end
 
   describe ".add_indexes" do
@@ -149,6 +177,7 @@ describe Mongoid::Indexable do
       Class.new do
         include Mongoid::Document
         field :a, as: :authentication_token
+        store_in collection: :specs
       end
     end
 
@@ -257,6 +286,21 @@ describe Mongoid::Indexable do
       end
     end
 
+    context "when providing a collation option", if: collation_supported? do
+
+      before do
+        klass.index({ name: 1 }, collation: { locale: 'en_US', strength: 2 })
+      end
+
+      let(:options) do
+        klass.index_specification(name: 1).options
+      end
+
+      it "sets the index with a collation option" do
+        expect(options).to eq(collation: { locale: 'en_US', strength: 2 })
+      end
+    end
+
     context "when providing a compound index" do
 
       before do

data/spec/mongoid/persistable/settable_spec.rb

@@ -263,6 +263,50 @@ describe Mongoid::Persistable::Settable do
     end
   end
 
+  context 'when the field is a nested hash' do
+
+    context 'when a leaf value in the nested hash is updated' do
+
+      let(:church) do
+        Church.new.tap do |a|
+          a.location = {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}
+          a.name = 'Church1'
+          a.save
+        end
+      end
+
+      before do
+        church.set('location.address.city' => 'Munich')
+      end
+
+      it 'does not reset the nested hash' do
+        expect(church.name).to eq('Church1')
+        expect(church.location).to eql({'address' => {'city' => 'Munich', 'street' => 'Yorckstr'}})
+      end
+    end
+
+
+    context 'when the nested hash is many levels deep' do
+
+      let(:church) do
+        Church.new.tap do |a|
+          a.location = {'address' => {'state' => {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}}}
+          a.name = 'Church1'
+          a.save
+        end
+      end
+
+      before do
+        church.set('location.address.state.address.city' => 'Munich')
+      end
+
+      it 'does not reset the nested hash' do
+        expect(church.name).to eq('Church1')
+        expect(church.location).to eql({'address' => {'state' => {'address' => {'city' => 'Munich', 'street' => 'Yorckstr'}}}})
+      end
+    end
+  end
+
   context 'when the field is not already set locally' do
 
     let(:church) do

data/spec/mongoid/query_cache_spec.rb

@@ -75,6 +75,40 @@ describe Mongoid::QueryCache do
         end
       end
 
+      context 'when the first query has a collation', if: collation_supported? do
+
+        before do
+          Band.where(name: 'DEPECHE MODE').collation(locale: 'en_US', strength: 2).to_a
+        end
+
+        context "when the next query has the same collation" do
+
+          it "uses the cache" do
+            expect_no_queries do
+              Band.where(name: 'DEPECHE MODE').collation(locale: 'en_US', strength: 2).to_a
+            end
+          end
+        end
+
+        context "when the next query does not have the same collation" do
+
+          it "queries again" do
+            expect_query(1) do
+              Band.where(name: 'DEPECHE MODE').collation(locale: 'fr', strength: 2).to_a
+            end
+          end
+        end
+
+        context "when the next query does not have a collation" do
+
+          it "queries again" do
+            expect_query(1) do
+              Band.where(name: 'DEPECHE MODE').to_a
+            end
+          end
+        end
+      end
+
       context "when the first query has no limit" do
 
         let(:game) do
@@ -173,6 +207,27 @@ describe Mongoid::QueryCache do
       end
     end
 
+    context "when sorting documents" do
+      before do
+        Band.asc(:id).to_a
+      end
+
+      context "with different selector" do
+
+        it "queries again" do
+          expect_query(1) do
+            Band.desc(:id).to_a
+          end
+        end
+      end
+
+      it "does not query again" do
+        expect_query(0) do
+          Band.asc(:id).to_a
+        end
+      end
+    end
+
     context "when query caching is enabled and the batch_size is set" do
 
       around(:each) do |example|
@@ -250,6 +305,37 @@ describe Mongoid::QueryCache do
     end
   end
 
+  context "when reloading a document" do
+
+    let!(:band_id) do
+      Band.create.id
+    end
+
+    context 'when query cache is disabled' do
+
+      before do
+        Mongoid::QueryCache.enabled = false
+      end
+
+      it "queries again" do
+        band = Band.find(band_id)
+        expect_query(1) do
+          band.reload
+        end
+      end
+    end
+
+    context 'when query cache is enabled' do
+
+      it "queries again" do
+        band = Band.find(band_id)
+        expect_query(1) do
+          band.reload
+        end
+      end
+    end
+  end
+
   context "when querying a very large collection" do
 
     before do

data/spec/mongoid/relations/cyclic_spec.rb

@@ -21,6 +21,17 @@ describe Mongoid::Relations::Cyclic do
       it "sets cyclic to true" do
         expect(document.cyclic).to be true
       end
+
+      context "when a query is executed" do
+
+        before do
+          document.save
+        end
+
+        it "queries the database, not memory" do
+          expect(Role.first).to be_a(Role)
+        end
+      end
     end
 
     context "when the name is not inflected easily" do
@@ -133,6 +144,17 @@ describe Mongoid::Relations::Cyclic do
         expect(document.class.relations['child_mango']).to be_cascading_callbacks
       end
     end
+
+    context "when a query is executed" do
+
+      before do
+        document.save
+      end
+
+      it "queries the database, not memory" do
+        expect(Shelf.first).to be_a(Shelf)
+      end
+    end
   end
 
   context "when building a namespaced hierarchy" do