mongoid 7.1.8 → 7.2.3

data/spec/mongoid/fields_spec.rb

@@ -833,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
 
@@ -844,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
@@ -1116,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
@@ -1135,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
 
@@ -1352,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/numeric_keys.yml

@@ -0,0 +1,104 @@
+- name: string key - matches
+  document:
+    # Document field names in MongoDB are always strings.
+    '42': foo
+  # The paths are also always strings.
+  key: '42'
+  
+  result:
+    - foo
+
+- name: string key - does not match
+  document:
+    # Document field names in MongoDB are always strings.
+    '42': foo
+  # The paths are also always strings.
+  key: '4'
+  
+  result: []
+
+- name: array value - matches
+  document:
+    '42':
+      - foo
+  key: '42'
+  
+  result:
+    - ['foo']
+
+- name: subfield of numeric key - matches
+  document:
+    '42':
+      foo: bar
+  key: 42.foo
+  
+  result: 
+    - bar
+
+- name: numeric key under array
+  document:
+    a:
+      -
+        '42': bar
+
+  key: a.42
+
+  result: 
+    - bar
+
+- name: multiple values under numeric key under array
+  document: &numeric-key-under-array
+    a:
+      -
+        '42': bar
+      -
+        '42': foo
+
+  key: a.42
+
+  result: 
+    - bar
+    - foo
+
+- name: array indexing with values under numeric key under array
+  document: *numeric-key-under-array
+
+  key: a.1
+
+  result: 
+    - 
+      '42': foo
+
+- name: multiple values under array under numeric key
+  document:
+    a:
+      '42':
+        -
+          foo: bar
+        -       
+          foo: baq
+
+  key: a.42.foo
+
+  result: 
+    - bar
+    - baq
+
+- name: path component interpretable as both array index and hash key
+  document: 
+    a:
+      -
+        '1': bar
+      -
+        '1': foo
+
+  key: a.1
+
+  result: 
+    # The order of these results isn't guaranteed:
+    # 1 interpreted as the array index:
+    -
+      '1': foo
+    # 1 interpreted as hash key:
+    - bar
+    - foo

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

@@ -0,0 +1,239 @@
+- name: scalar retrieval
+  document:
+    name: foo
+  key: name
+  
+  result: 
+    - foo
+
+- name: scalar leaf
+  document: &foo-bar-foo-bar-2
+    foo:
+      bar:
+        foo:
+          bar:
+            2
+  key: foo.bar.foo.bar
+  
+  result:
+    - 2
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          2
+
+- name: null leaf
+  document:
+    name:
+  key: name
+  
+  result: 
+    - ~
+
+- name: array leaf
+  document: &foo-bar-foo-bar-array-2
+    foo:
+      bar:
+        foo:
+          bar:
+            - 2
+  key: foo.bar.foo.bar
+  
+  result:
+    - [2]
+
+- name: scalar non-leaf
+  document: *foo-bar-foo-bar-array-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          - 2
+
+- name: array non-leaf
+  document: &foo-bar-array-foo-bar-2
+    foo:
+      -
+        bar:
+          foo:
+            bar:
+              2
+  key: foo.bar.foo.bar
+  
+  result:
+    - 2
+
+- name: array non-leaf with non-leaf query
+  document: *foo-bar-array-foo-bar-2
+  key: foo.bar
+  
+  result:
+    -
+      foo:
+        bar:
+          2
+
+- name: array non-leaf with query for missing non-leaf key
+  document: *foo-bar-array-foo-bar-2
+  key: foo.missing
+  
+  result: []
+
+- name: path past end of document
+  document: &foo-hello-world
+    foo:
+      hello: world
+  key: foo.bar.foo.bar
+  
+  result: []
+
+- name: query for missing leaf key
+  document: *foo-hello-world
+  key: foo.bar
+  
+  result: []
+
+- name: numeric path component when traversing hash
+  document:
+    foo:
+      "10":
+        42
+  key: "foo.10"
+
+  result: 
+    - 42
+
+- name: array index - hash leaf
+  document: &foo-one-two
+    foo:
+      - one: 1
+      - two: 2
+    bar: [3, 4]
+  key: foo.1.two
+  
+  result: 
+    - 2
+
+- name: array index - hash non-leaf
+  document: *foo-one-two
+  key: foo.1
+  
+  result:
+    -
+      two: 2
+
+- name: array index - scalar leaf
+  document: *foo-one-two
+  key: bar.1
+  
+  result: 
+    - 4
+
+- name: array index - scalar leaf - missing
+  document: *foo-one-two
+  key: bar.2
+  
+  result: []
+
+- name: array index - scalar leaf - missing with further hash subscription
+  document: *foo-one-two
+  key: bar.2.any
+  
+  result: []
+
+- 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
+  
+  result:
+    - Steve
+
+- name: non-sequential nested arrays - hash non-leaf - one value
+  document: *books-authors
+  key: books.0
+  
+  result:
+    -
+      authors:
+        - name: Steve
+
+- name: non-sequential nested arrays - hash non-leaf - multiple values
+  document: *books-authors
+  key: books.1
+  
+  result:
+    -
+      authors:
+        - name: Boris
+        - name: Pasha
+
+- name: sequential nested arrays - numerically indexed leaf
+  document: &groups
+    groups:
+      - [1]
+  key: groups.0.0
+  
+  result: 
+    - 1
+
+- name: sequential nested arrays - numerically indexed leaf - missing
+  document: *groups
+  key: groups.0.1
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path through non-leaf
+  document: *groups
+  key: groups.missing
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path through leaf
+  document: *groups
+  key: groups.0.missing
+  
+  result: []
+
+- name: sequential nested arrays - missing hash path past leaf
+  document: *groups
+  key: groups.0.0.missing
+  
+  result: []
+
+- name: mix of arrays and hashes in an array
+  document:
+    foo:
+      -
+        -
+          bar: 1
+      - bar: 2
+  key: foo.bar
+  
+  result: 
+    - 2
+
+- name: numeric index through a primitive value not supporting subscription operator
+  document:
+    occupants:
+      -
+        age: 20
+  key:
+    occupants.0.age.0
+    
+  result: []