mongoid 7.1.2 → 7.2.0

data/spec/mongoid/fields_spec.rb

@@ -431,7 +431,9 @@ describe Mongoid::Fields do
     context "when the Symbol type is used" do
 
       before do
-        expect(Mongoid.logger).to receive(:warn)
+        Mongoid::Fields::Validators::Macro.class_eval do
+          @field_type_is_symbol_warned = false
+        end
       end
 
       after do
@@ -439,8 +441,29 @@ describe Mongoid::Fields do
       end
 
       it "warns that the BSON symbol type is deprecated" do
+        expect(Mongoid.logger).to receive(:warn)
+
+        Band.field :should_warn, type: Symbol
+      end
+
+      it "warns on first use of Symbol type only" do
+        expect(Mongoid.logger).to receive(:warn).once
+
         Band.field :should_warn, type: Symbol
       end
+
+      context 'when using Symbol field type in multiple classes' do
+        after do
+          Truck.fields.delete("should_warn")
+        end
+
+        it "warns on first use of Symbol type only" do
+          expect(Mongoid.logger).to receive(:warn).once
+
+          Band.field :should_warn, type: Symbol
+          Truck.field :should_warn, type: Symbol
+        end
+      end
     end
 
     context "when the options are not valid" do
@@ -810,7 +833,8 @@ describe Mongoid::Fields do
       end
 
       it "does not return subclass defaults" do
-        expect(shape.pre_processed_defaults).to eq([ "_id", "x", "y", "_type" ])
+        expect(shape.pre_processed_defaults).to eq([ "_id", "x", "y" ])
+        expect(shape.post_processed_defaults).to eq([ "_type" ])
       end
     end
 
@@ -821,7 +845,8 @@ describe Mongoid::Fields do
       end
 
       it "has the parent and child defaults" do
-        expect(circle.pre_processed_defaults).to eq([ "_id", "x", "y", "_type", "radius" ])
+        expect(circle.pre_processed_defaults).to eq([ "_id", "x", "y", "radius" ])
+        expect(circle.post_processed_defaults).to eq([ "_type" ])
       end
     end
   end
@@ -1093,6 +1118,10 @@ describe Mongoid::Fields do
       it "does not return subclass fields" do
         expect(shape.fields.keys).to_not include("radius")
       end
+
+      it 'includes _type field' do
+        expect(shape.fields.keys).to include("_type")
+      end
     end
 
     context "on subclasses" do
@@ -1112,6 +1141,28 @@ describe Mongoid::Fields do
       it "includes the child fields" do
         expect(circle.fields.keys).to include("radius")
       end
+
+      it 'includes _type field' do
+        expect(circle.fields.keys).to include("_type")
+      end
+    end
+
+    context "on new subclasses" do
+      it "all subclasses get the discriminator key" do
+        class DiscriminatorParent
+          include Mongoid::Document
+        end
+
+        class DiscriminatorChild1 < DiscriminatorParent
+        end
+
+        class DiscriminatorChild2 < DiscriminatorParent
+        end
+
+        expect(DiscriminatorParent.fields.keys).to include("_type")
+        expect(DiscriminatorChild1.fields.keys).to include("_type")
+        expect(DiscriminatorChild2.fields.keys).to include("_type")
+      end
     end
   end
 
@@ -1329,4 +1380,22 @@ describe Mongoid::Fields do
       end
     end
   end
+
+  describe '_type field' do
+    context 'on parent class' do
+      let(:shape) { Shape.new }
+
+      it 'is correctly set' do
+        shape.attributes['_type'].should == 'Shape'
+      end
+    end
+
+    context 'on child class' do
+      let(:circle) { Circle.new }
+
+      it 'is correctly set' do
+        circle.attributes['_type'].should == 'Circle'
+      end
+    end
+  end
 end

data/spec/mongoid/findable_spec.rb

@@ -479,6 +479,38 @@ describe Mongoid::Findable do
     end
   end
 
+  describe '.count' do
+    context 'when the collection is not empty' do
+      before do
+        Band.create!(name: "Tool")
+        Band.create!(name: "Photek")
+      end
+
+      it 'returns the currect count' do
+        expect(Band.count).to eq(2)
+      end
+    end
+  end
+
+  describe '.estimated_count' do
+    context 'when the collection is not empty' do
+      before do
+        Band.create(name: "Tool")
+        Band.create(name: "Photek")
+      end
+
+      it 'returns the correct count' do
+        expect(Band.estimated_count).to eq(2)
+      end
+    end
+
+    context 'when the collection is empty' do
+      it 'returns the correct count' do
+        expect(Band.estimated_count).to eq(0)
+      end
+    end
+  end
+
   Mongoid::Criteria::Queryable::Selectable.forwardables.each do |method|
 
     describe "##{method}" do

data/spec/mongoid/indexable_spec.rb

@@ -191,6 +191,32 @@ describe Mongoid::Indexable do
         expect(spec.options).to eq(unique: false, background: true)
       end
     end
+
+    context "when using a custom discriminator_key" do 
+      context "when indexes have not been added" do
+        let(:klass) do
+          Class.new do
+            include Mongoid::Document
+            self.discriminator_key = "dkey"
+            def self.hereditary?
+              true
+            end
+          end
+        end
+  
+        before do
+          klass.add_indexes
+        end
+  
+        let(:spec) do
+          klass.index_specification(dkey: 1)
+        end
+  
+        it "adds the _type index" do
+          expect(spec.options).to eq(unique: false, background: true)
+        end
+      end
+    end
   end
 
   describe ".index" do
@@ -383,7 +409,7 @@ describe Mongoid::Indexable do
       end
     end
 
-    context "when providing a geospacial index" do
+    context "when providing a geospatial index" do
 
       before do
         klass.index({ location: "2d" }, { min: -200, max: 200, bits: 32 })
@@ -393,7 +419,7 @@ describe Mongoid::Indexable do
         klass.index_specification(location: "2d").options
       end
 
-      it "sets the geospacial index" do
+      it "sets the geospatial index" do
         expect(options).to eq({ min: -200, max: 200, bits: 32 })
       end
     end

data/spec/mongoid/inspectable_spec.rb

@@ -26,12 +26,39 @@ describe Mongoid::Inspectable do
       end
 
       it "displays defined fields" do
-        expect(inspected).to include("title: \"CEO\"")
+        expect(inspected).to include(%q,title: "CEO",)
       end
 
       it "displays field aliases" do
         expect(inspected).to include("t(test):")
       end
+
+      it "displays the default discriminator key" do 
+        expect(inspected).to include(%q,_type: "Person",)
+      end
+    end
+
+    context "when using a custom discriminator key" do
+
+      before do 
+        Person.discriminator_key = "dkey"
+      end
+
+      after do 
+        Person.discriminator_key = nil
+      end
+
+      let(:person) do
+        Person.new(title: "CEO")
+      end
+
+      let(:inspected) do
+        person.inspect
+      end
+
+      it "displays the new discriminator key" do 
+        expect(inspected).to include(%q,dkey: "Person",)
+      end
     end
 
     context "when allowing dynamic fields" do
@@ -45,7 +72,7 @@ describe Mongoid::Inspectable do
       end
 
       it "includes dynamic attributes" do
-        expect(inspected).to include("some_attribute: \"foo\"")
+        expect(inspected).to include(%q,some_attribute: "foo",)
       end
     end
   end

data/spec/mongoid/interceptable_spec.rb

@@ -1707,8 +1707,8 @@ describe Mongoid::Interceptable do
   context "when loading a model multiple times" do
 
     before do
-      load "spec/app/models/callback_test.rb"
-      load "spec/app/models/callback_test.rb"
+      load File.join(MODELS, "callback_test.rb")
+      load File.join(MODELS, "callback_test.rb")
     end
 
     let(:callback) do

data/spec/mongoid/matcher/extract_attribute_data/traversal.yml

@@ -0,0 +1,259 @@
+- name: scalar retrieval
+  document:
+    name: foo
+  key: name
+  
+  exists: true
+  value: foo
+  expanded: false
+
+- name: scalar leaf
+  document: &foo-bar-foo-bar-2
+    foo:
+      bar:
+        foo:
+          bar:
+            2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value: 2
+  expanded: false
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    foo:
+      bar:
+        2
+  expanded: false
+
+- name: array leaf
+  document: &foo-bar-foo-bar-array-2
+    foo:
+      bar:
+        foo:
+          bar:
+            - 2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value:
+    - 2
+  expanded: false
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-array-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    foo:
+      bar:
+        - 2
+  expanded: false
+
+- name: array non-leaf
+  document: &foo-bar-array-foo-bar-2
+    foo:
+      -
+        bar:
+          foo:
+            bar:
+              2
+  key: foo.bar.foo.bar
+  
+  exists: true
+  value:
+    - 2
+  expanded: true
+
+- name: array non-leaf with non-leaf query
+  document: *foo-bar-array-foo-bar-2
+  key: foo.bar
+  
+  exists: true
+  value:
+    -
+      foo:
+        bar:
+          2
+  expanded: true
+
+- name: array non-leaf with query for missing non-leaf key
+  document: *foo-bar-array-foo-bar-2
+  key: foo.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: path past end of document
+  document: &foo-hello-world
+    foo:
+      hello: world
+  key: foo.bar.foo.bar
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: query for missing leaf key
+  document: *foo-hello-world
+  key: foo.bar
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: array index - hash leaf
+  document: &foo-one-two
+    foo:
+      - one: 1
+      - two: 2
+    bar: [3, 4]
+  key: foo.1.two
+  
+  exists: true
+  value: 2
+  expanded: false
+
+- name: array index - hash non-leaf
+  document: *foo-one-two
+  key: foo.1
+  
+  exists: true
+  value:
+    two: 2
+  expanded: false
+
+- name: array index - scalar leaf
+  document: *foo-one-two
+  key: bar.1
+  
+  exists: true
+  value: 4
+  expanded: false
+
+- name: array index - scalar leaf - missing
+  document: *foo-one-two
+  key: bar.2
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: array index - scalar leaf - missing with further hash subscription
+  document: *foo-one-two
+  key: bar.2.any
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: non-sequential nested arrays - hash leaf - one value
+  document: &books-authors
+    books:
+      -
+        authors:
+          - name: Steve
+      -
+        authors:
+          - name: Boris
+          - name: Pasha
+  key: books.0.authors.name
+  
+  exists: true
+  value: [Steve]
+  expanded: true
+
+- name: non-sequential nested arrays - hash non-leaf - one value
+  document: *books-authors
+  key: books.0
+  
+  exists: true
+  value:
+    authors:
+      - name: Steve
+  expanded: false
+
+- name: non-sequential nested arrays - hash non-leaf - multiple values
+  document: *books-authors
+  key: books.1
+  
+  exists: true
+  value:
+    authors:
+      - name: Boris
+      - name: Pasha
+  expanded: false
+
+- name: sequential nested arrays - numerically indexed leaf
+  document: &groups
+    groups:
+      - [1]
+  key: groups.0.0
+  
+  exists: true
+  value: 1
+  expanded: false
+
+- name: sequential nested arrays - numerically indexed leaf - missing
+  document: *groups
+  key: groups.0.1
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: sequential nested arrays - missing hash path through non-leaf
+  document: *groups
+  key: groups.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: sequential nested arrays - missing hash path through leaf
+  document: *groups
+  key: groups.0.missing
+  
+  exists: false
+  value: []
+  expanded: true
+
+- name: sequential nested arrays - missing hash path past leaf
+  document: *groups
+  key: groups.0.0.missing
+  
+  exists: false
+  value: ~
+  expanded: false
+
+- name: mix of arrays and hashes in an array
+  document:
+    foo:
+      -
+        -
+          bar: 1
+      - bar: 2
+  key: foo.bar
+  
+  exists: true
+  value: [2]
+  expanded: true
+
+- name: numeric index through a primitive value not supporting subscription operator
+  document:
+    occupants:
+      -
+        age: 20
+  key:
+    occupants.0.age.0
+    
+  exists: false
+  value: ~
+  expanded: false