chewy 0.8.4 → 7.3.4

data/spec/chewy/fields/base_spec.rb

@@ -5,385 +5,694 @@ describe Chewy::Fields::Base do
   specify { expect(described_class.new('name', type: 'integer').options[:type]).to eq('integer') }
 
   describe '#compose' do
-    let(:field) { described_class.new(:name, value: ->(o){ o.value }) }
+    let(:field) { described_class.new(:name, value: ->(o) { o.value }) }
 
-    specify { expect(field.compose(double(value: 'hello'))).to eq({name: 'hello'}) }
-    specify { expect(field.compose(double(value: ['hello', 'world']))).to eq({name: ['hello', 'world']}) }
-
-    specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq({name: 'hello'}) }
-    specify { expect(described_class.new(:false_value).compose({false_value: false})).to eq({false_value: false}) }
-    specify { expect(described_class.new(:true_value).compose({true_value: true})).to eq({true_value: true}) }
-    specify { expect(described_class.new(:nil_value).compose({nil_value: nil})).to eq({nil_value: nil}) }
+    specify { expect(field.compose(double(value: 'hello'))).to eq(name: 'hello') }
+    specify { expect(field.compose(double(value: %w[hello world]))).to eq(name: %w[hello world]) }
 
+    specify do
+      expect(described_class.new(:name, value: :last_name).compose(double(last_name: 'hello'))).to eq(name: 'hello')
+    end
+    specify do
+      expect(described_class.new(:name, value: :last_name).compose('last_name' => 'hello')).to eq(name: 'hello')
+    end
+    specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq(name: 'hello') }
+    specify { expect(described_class.new(:false_value).compose(false_value: false)).to eq(false_value: false) }
+    specify { expect(described_class.new(:true_value).compose(true_value: true)).to eq(true_value: true) }
+    specify { expect(described_class.new(:nil_value).compose(nil_value: nil)).to eq(nil_value: nil) }
 
     context 'nested fields' do
       before do
-        field.children.push(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
-        field.children.push(described_class.new(:subname2, value: ->{ subvalue2 }))
+        field.children.push(described_class.new(:subname1, value: ->(o) { o.subvalue1 }))
+        field.children.push(described_class.new(:subname2, value: -> { subvalue2 }))
         field.children.push(described_class.new(:subname3))
       end
 
-      specify { expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
-        .to eq({name: {'subname1' => 'hello', 'subname2' => 'value', 'subname3' => 'world'}}) }
-      specify { expect(field.compose(double(value: [
-        double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
-        double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
-      ]))).to eq({name: [
-        {'subname1' => 'hello1', 'subname2' => 'value1', 'subname3' => 'world1'},
-        {'subname1' => 'hello2', 'subname2' => 'value2', 'subname3' => 'world2'}
-      ]}) }
+      specify do
+        expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
+          .to eq(name: {subname1: 'hello', subname2: 'value', subname3: 'world'})
+      end
+      specify do
+        expect(field.compose(double(value: [
+          double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
+          double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
+        ]))).to eq(name: [
+          {subname1: 'hello1', subname2: 'value1', subname3: 'world1'},
+          {subname1: 'hello2', subname2: 'value2', subname3: 'world2'}
+        ])
+      end
     end
 
     context 'parent objects' do
-      let!(:country) { described_class.new(:name, value: ->(country){ country.cities }) }
-      let!(:city) { described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } }) }
-      let!(:district) { described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] }) }
+      let!(:country) { described_class.new(:name, value: ->(country, crutches) { country.cities.map { |city| double(districts: city.districts, name: crutches.city_name) } }) }
+      let!(:city) { described_class.new(:name, value: ->(city, country, crutches) { city.districts.map { |district| [district, country.name, crutches.suffix] } }) }
+      let!(:district) { described_class.new(:name, value: ->(district, city, country, crutches) { [district, city.name, country.name, crutches] }) }
+      let(:crutches) { double(suffix: 'suffix', city_name: 'Bangkok') }
 
       before do
         country.children.push(city)
         city.children.push(district)
       end
 
-      specify { expect(country.compose(double(name: 'Thailand', cities: [
-        double(name: 'Bangkok', districts: ['First', 'Second'])
-      ]))).to eq(name: [
-        { 'name' => [
-          { 'name' => [['First', 'Thailand'], 'Bangkok', 'Thailand'] },
-          { 'name' => [['Second', 'Thailand'], 'Bangkok', 'Thailand'] }
-        ] }
-      ]) }
+      specify do
+        expect(country.compose(double(name: 'Thailand', cities: [
+          double(districts: %w[First Second])
+        ]), crutches)).to eq(name: [
+          {name: [
+            {name: [%w[First Thailand suffix], 'Bangkok', 'Thailand', crutches]},
+            {name: [%w[Second Thailand suffix], 'Bangkok', 'Thailand', crutches]}
+          ]}
+        ])
+      end
     end
 
     context 'implicit values' do
-      let(:field) { described_class.new(:name, type: 'string') }
+      let(:field) { described_class.new(:name, type: 'integer') }
       before do
         field.children.push(described_class.new(:name))
         field.children.push(described_class.new(:untouched))
       end
 
-      specify { expect(field.compose(double(name: 'Alex'))).to eq({name: 'Alex'}) }
+      specify { expect(field.compose(double(name: 'Alex'))).to eq(name: 'Alex') }
     end
 
     context 'hash values' do
       let(:field) { described_class.new(:name, type: 'object') }
-      let(:object) { double(name: { key1: 'value1', key2: 'value2'}) }
+      let(:object) { double(name: {key1: 'value1', key2: 'value2'}) }
 
       before do
-        field.children.push(described_class.new(:key1, value: ->(h){ h[:key1] }))
-        field.children.push(described_class.new(:key2, value: ->(h){ h[:key2] }))
+        field.children.push(described_class.new(:key1, value: ->(h) { h[:key1] }))
+        field.children.push(described_class.new(:key2, value: ->(h) { h[:key2] }))
       end
 
-      specify{ expect(field.compose(object)).to eq({ name: { 'key1' => 'value1', 'key2' => 'value2'} }) }
+      specify { expect(field.compose(object)).to eq(name: {key1: 'value1', key2: 'value2'}) }
     end
   end
 
   describe '#mappings_hash' do
     let(:field) { described_class.new(:name, type: :object) }
-    let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}", type: "string#{i+1}") } }
-    let(:fields2) { 2.times.map { |i| described_class.new("name#{i+3}", type: "string#{i+3}") } }
+    let(:fields1) { Array.new(2) { |i| described_class.new("name#{i + 1}", type: "integer#{i + 1}") } }
+    let(:fields2) { Array.new(2) { |i| described_class.new("name#{i + 3}", type: "integer#{i + 3}") } }
     before do
       fields1.each { |m| field.children.push(m) }
       fields2.each { |m| fields1[0].children.push(m) }
     end
 
-    specify { expect(field.mappings_hash).to eq({name: {type: :object, properties: {
-      name1: {type: 'string1', fields: {
-        name3: {type: 'string3'}, name4: {type: 'string4'}
-      }}, name2: {type: 'string2'}
-    }}}) }
+    specify do
+      expect(field.mappings_hash).to eq(name: {type: :object, properties: {
+        name1: {type: 'integer1', fields: {
+          name3: {type: 'integer3'}, name4: {type: 'integer4'}
+        }}, name2: {type: 'integer2'}
+      }})
+    end
 
     context do
-      let(:field) { described_class.new(:name, type: :string) }
-      let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}") } }
-
-      specify { expect(field.mappings_hash).to eq({name: {type: :string, fields: {
-        name1: {type: 'object', properties: {
-          name3: {type: 'string3'}, name4: {type: 'string4'}
-        }}, name2: {type: 'string'}
-      }}}) }
+      let(:field) { described_class.new(:name, type: :integer) }
+      let(:fields1) do
+        [described_class.new(:name1), described_class.new(:name2, type: 'integer')]
+      end
+
+      specify do
+        expect(field.mappings_hash).to eq(name: {type: :integer, fields: {
+          name1: {type: 'object', properties: {
+            name3: {type: 'integer3'}, name4: {type: 'integer4'}
+          }}, name2: {type: 'integer'}
+        }})
+      end
     end
   end
 
   context 'integration' do
-    context 'objects, hashes and arrays' do
+    context 'default field type' do
       before do
         stub_index(:events) do
-          define_type :event do
+          field :id
+          field :category do
             field :id
-            field :category do
+            field :licenses do
               field :id
-              field :licenses do
-                field :id
-                field :name
-              end
+              field :created_at, type: 'time'
             end
           end
         end
       end
 
-      specify do
-        expect(EventsIndex::Event.mappings_hash).to eq({ event: {
-          properties: {
-            id: { type: 'string' },
-            category: {
-              type: 'object',
-              properties: {
-                id: { type: 'string' },
-                licenses: {
-                  type: 'object',
-                  properties: {
-                    id: { type: 'string' },
-                    name: { type: 'string' } } } } } } } })
+      around do |example|
+        previous_type = Chewy.default_field_type
+        Chewy.default_field_type = 'integer'
+        example.run
+        Chewy.default_field_type = previous_type
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-          id: 1, category: { id: 2, licenses: { id: 3, name: 'Name' } }
-        )).to eq({
-          event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        })
+        expect(EventsIndex.mappings_hash).to eq(
+          mappings: {
+            properties: {
+              id: {type: 'integer'},
+              category: {
+                type: 'object',
+                properties: {
+                  id: {type: 'integer'},
+                  licenses: {
+                    type: 'object',
+                    properties: {
+                      id: {type: 'integer'},
+                      created_at: {type: 'time'}
+                    }
+                  }
+                }
+              }
+            }
+          }
+        )
       end
+    end
 
-      specify do
-        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
-          { id: 2, 'licenses' => { id: 3, name: 'Name1' } },
-          { id: 4, licenses: nil}
-        ])).to eq({
-          event: { 'id' => 1, 'category' => [
-            { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-            {'id' => 4, 'licenses' => nil.as_json }
-          ] }
-        })
+    context 'objects, hashes and arrays' do
+      before do
+        stub_index(:events) do
+          field :id
+          field :category do
+            field :id
+            field :licenses do
+              field :id
+              field :name
+            end
+          end
+        end
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose('id' => 1, category: { id: 2, licenses: [
-          { id: 3, name: 'Name1' }, { id: 4, name: 'Name2' }
-        ] })).to eq({
-          event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
-            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
-          ] } }
-        })
+        expect(
+          EventsIndex.root.compose({id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}})
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
-          { id: 2, licenses: [
-            { id: 3, 'name' => 'Name1' }, { id: 4, name: 'Name2' }
-          ] },
-          { id: 5, licenses: [] }
-        ])).to eq({
-          event: { 'id' => 1, 'category' => [
-            { 'id' => 2, 'licenses' => [
-              { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-            ] },
-            {'id' => 5, 'licenses' => [] }
-          ] }
-        })
+        expect(
+          EventsIndex.root.compose({id: 1, category: [
+            {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
+            {id: 4, licenses: nil}
+          ]})
+        ).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
+          {'id' => 4, 'licenses' => nil.as_json}
+        ])
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-          double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name')))
-        )).to eq({
-          event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        })
+        expect(
+          EventsIndex.root.compose({
+            'id' => 1,
+            category: {
+              id: 2, licenses: [
+                {id: 3, name: 'Name1'},
+                {id: 4, name: 'Name2'}
+              ]
+            }
+          })
+        ).to eq(
+          'id' => 1,
+          'category' => {
+            'id' => 2,
+            'licenses' => [
+              {'id' => 3, 'name' => 'Name1'},
+              {'id' => 4, 'name' => 'Name2'}
+            ]
+          }
+        )
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
-          double(id: 2, licenses: double(id: 3, name: 'Name1')),
-          double(id: 4, licenses: nil)
-        ]))).to eq({
-          event: { 'id' => 1, 'category' => [
-            { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-            {'id' => 4, 'licenses' => nil.as_json }
-          ] }
-        })
+        expect(
+          EventsIndex.root.compose({id: 1, category: [
+            {id: 2, licenses: [
+              {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
+            ]},
+            {id: 5, licenses: []}
+          ]})
+        ).to eq(
+          'id' => 1,
+          'category' => [
+            {'id' => 2, 'licenses' => [
+              {'id' => 3, 'name' => 'Name1'},
+              {'id' => 4, 'name' => 'Name2'}
+            ]},
+            {'id' => 5, 'licenses' => []}
+          ]
+        )
+      end
+      specify do
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name'))))
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: double(id: 2, licenses: [
-          double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-        ])))).to eq({
-          event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
-            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
-          ] } }
-        })
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: [
+            double(id: 2, licenses: double(id: 3, name: 'Name1')),
+            double(id: 4, licenses: nil)
+          ]))
+        ).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
+          {'id' => 4, 'licenses' => nil.as_json}
+        ])
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
-          double(id: 2, licenses: [
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: double(id: 2, licenses: [
             double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-          ]),
-          double(id: 5, licenses: [])
-        ]))).to eq({
-          event: { 'id' => 1, 'category' => [
-            { 'id' => 2, 'licenses' => [
-              { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-            ] },
-            {'id' => 5, 'licenses' => [] }
-          ] }
-        })
+          ])))
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+          {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+        ]})
+      end
+
+      specify do
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: [
+            double(id: 2, licenses: [
+              double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
+            ]),
+            double(id: 5, licenses: [])
+          ]))
+        ).to eq(
+          'id' => 1, 'category' => [
+            {'id' => 2, 'licenses' => [
+              {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+            ]},
+            {'id' => 5, 'licenses' => []}
+          ]
+        )
       end
     end
 
     context 'custom methods' do
       before do
         stub_index(:events) do
-          define_type :event do
-            field :id
-            field :category, value: ->{ categories } do
-              field :id
-              field :licenses, value: ->{ license } do
-                field :id
-                field :name
-              end
+          field :id, type: 'integer'
+          field :category, value: -> { categories } do
+            field :id, type: 'integer'
+            field :licenses, value: -> { license } do
+              field :id, type: 'integer'
+              field :name
             end
           end
         end
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-          double(id: 1, categories: double(id: 2, license: double(id: 3, name: 'Name')))
-        )).to eq({
-          event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        })
+        expect(
+          EventsIndex.root.compose(
+            double(
+              id: 1, categories: double(
+                id: 2, license: double(
+                  id: 3, name: 'Name'
+                )
+              )
+            )
+          )
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
     end
 
     context 'objects and multi_fields' do
       before do
         stub_index(:events) do
-          define_type :event do
-            field :id
-            field :name, type: 'string' do
-              field :raw, analyzer: 'my_own'
-            end
-            field :category, type: 'object'
+          field :id, type: 'integer'
+          field :name, type: 'integer' do
+            field :raw, analyzer: 'my_own'
           end
+          field :category, type: 'object'
         end
       end
 
       specify do
-        expect(EventsIndex::Event.mappings_hash).to eq({ event: {
-          properties: {
-            id: { type: 'string' },
-            name: {
-              type: 'string',
-              fields: {
-                raw: { analyzer: 'my_own', type: 'string' }
-              }
-            },
-            category: { type: 'object' }
+        expect(EventsIndex.mappings_hash).to eq(
+          mappings: {
+            properties: {
+              id: {type: 'integer'},
+              name: {
+                type: 'integer',
+                fields: {
+                  raw: {analyzer: 'my_own', type: Chewy.default_field_type}
+                }
+              },
+              category: {type: 'object'}
+            }
           }
-        } })
+        )
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-          double(id: 1, name: 'Jonny', category: double(id: 2, as_json: {name: 'Borogoves'}))
-        )).to eq({
-          event: {
-            'id' => 1,
-            'name' => 'Jonny',
-            'category' => { 'name' => 'Borogoves' }
-          }
-        })
+        expect(
+          EventsIndex.root.compose(
+            double(
+              id: 1, name: 'Jonny', category: double(
+                id: 2, as_json: {'name' => 'Borogoves'}
+              )
+            )
+          )
+        ).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => {'name' => 'Borogoves'}
+        )
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-          double(id: 1, name: 'Jonny', category: [
-            double(id: 2, as_json: { name: 'Borogoves1' }),
-            double(id: 3, as_json: { name: 'Borogoves2' })
-          ])
-        )).to eq({
-          event: {
-            'id' => 1,
-            'name' => 'Jonny',
-            'category' => [
-              { 'name' => 'Borogoves1' },
-              { 'name' => 'Borogoves2' }
-            ]
-          }
-        })
+        expect(
+          EventsIndex.root.compose(
+            double(id: 1, name: 'Jonny', category: [
+              double(id: 2, as_json: {'name' => 'Borogoves1'}),
+              double(id: 3, as_json: {'name' => 'Borogoves2'})
+            ])
+          )
+        ).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => [
+            {'name' => 'Borogoves1'},
+            {'name' => 'Borogoves2'}
+          ]
+        )
       end
     end
 
-    context 'objects and scopes', :orm do
+    context 'ignore_blank option for field method', :orm do
       before do
+        stub_model(:location)
         stub_model(:city)
         stub_model(:country)
 
-        case adapter
-        when :active_record
-          City.belongs_to :country
-          if ActiveRecord::VERSION::MAJOR >= 4
-            Country.has_many :cities, -> { order :id }
-          else
-            Country.has_many :cities, order: :id
-          end
-        when :mongoid
-          City.belongs_to :country
-          Country.has_many :cities, order: :id.asc
-        when :sequel
-          City.many_to_one :country
-          Country.one_to_many :cities, order: :id
-        end
+        City.belongs_to :country
+        Location.belongs_to :city
+        City.has_one :location, -> { order :id }
+        Country.has_many :cities, -> { order :id }
+      end
 
-        stub_index(:countries) do
-          define_type Country do
+      context 'text fields with and without ignore_blank option' do
+        before do
+          stub_index(:countries) do
+            index_scope Country
             field :id
             field :cities do
               field :id
               field :name
+              field :historical_name, ignore_blank: false
+              field :description, ignore_blank: true
             end
           end
         end
+
+        let(:country_with_cities) do
+          cities = [
+            City.create!(id: 1, name: '', historical_name: '', description: ''),
+            City.create!(id: 2, name: '', historical_name: '', description: '')
+          ]
+
+          Country.create!(id: 1, cities: cities)
+        end
+
+        specify do
+          expect(CountriesIndex.root.compose(country_with_cities)).to eq(
+            'id' => 1, 'cities' => [
+              {'id' => 1, 'name' => '', 'historical_name' => ''},
+              {'id' => 2, 'name' => '', 'historical_name' => ''}
+            ]
+          )
+        end
+        specify { expect(CountriesIndex.reset).to eq(true) }
       end
 
-      let(:country_with_cities) do
-        cities = [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')]
+      context 'nested fields' do
+        context 'with ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities, ignore_blank: true do
+                field :id
+                field :name
+                field :historical_name, ignore_blank: true
+                field :description
+              end
+            end
+          end
 
-        if adapter == :sequel
-          Country.create(id: 1).tap do |country|
-            cities.each { |city| country.add_city(city) }
+          let(:country) { Country.create!(id: 1, cities: cities) }
+          context('without cities') do
+            let(:cities) { [] }
+            specify do
+              expect(CountriesIndex.root.compose(country))
+                .to eq('id' => 1)
+            end
+          end
+          context('with cities') do
+            let(:cities) { [City.create!(id: 1, name: '', historical_name: '')] }
+            specify do
+              expect(CountriesIndex.root.compose(country)).to eq(
+                'id' => 1, 'cities' => [
+                  {'id' => 1, 'name' => '', 'description' => nil}
+                ]
+              )
+            end
+          end
+        end
+
+        context 'with ignore_blank: false option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities, ignore_blank: false do
+                field :id
+                field :name
+                field :historical_name
+                field :description
+              end
+            end
+          end
+
+          let(:country_with_cities) { Country.create!(id: 1) }
+
+          specify do
+            expect(CountriesIndex.root.compose(country_with_cities))
+              .to eq('id' => 1, 'cities' => [])
+          end
+        end
+
+        context 'without ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :historical_name
+                field :description
+              end
+            end
+          end
+
+          let(:country_with_cities) { Country.create!(id: 1) }
+
+          specify do
+            expect(CountriesIndex.root.compose(country_with_cities))
+              .to eq('id' => 1, 'cities' => [])
           end
-        else
-          Country.create!(id: 1, cities: cities)
         end
       end
 
+      context 'geo_point field type' do
+        context 'with ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point, ignore_blank: true do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'name' => 'City1', 'location' => {}},
+                  {'id' => 2, 'name' => 'City2', 'location' => {}}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'name' => 'City1'},
+                {'id' => 2, 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+
+        context 'join field type' do
+          before do
+            stub_model(:comment)
+            stub_index(:comments) do
+              index_scope Comment
+              field :id
+              field :hierarchy, type: :join, relations: {question: %i[answer comment], answer: :vote, vote: :subvote}, join: {type: :comment_type, id: :commented_id}
+            end
+          end
+
+          specify do
+            expect(
+              CommentsIndex.root.compose(
+                {'id' => 1, 'comment_type' => 'question'}
+              )
+            ).to eq(
+              {'id' => 1, 'hierarchy' => 'question'}
+            )
+
+            expect(
+              CommentsIndex.root.compose(
+                {'id' => 2, 'comment_type' => 'answer', 'commented_id' => 1}
+              )
+            ).to eq(
+              {'id' => 2, 'hierarchy' => {'name' => 'answer', 'parent' => 1}}
+            )
+
+            expect do
+              CommentsIndex.root.compose(
+                {'id' => 2, 'comment_type' => 'asd', 'commented_id' => 1}
+              )
+            end.to raise_error Chewy::InvalidJoinFieldType
+          end
+        end
+
+        context 'without ignore_blank option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'name' => 'City1', 'location' => {}},
+                  {'id' => 2, 'name' => 'City2', 'location' => {}}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'name' => 'City1'},
+                {'id' => 2, 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+
+        context 'with ignore_blank: false flag' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point, ignore_blank: false do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'location' => {}, 'name' => 'City1'},
+                  {'id' => 2, 'location' => '', 'name' => 'City2'}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'location' => {}, 'name' => 'City1'},
+                {'id' => 2, 'location' => '', 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+      end
+    end
+
+    context 'objects and scopes', :orm do
+      before do
+        stub_model(:city)
+        stub_model(:country)
+
+        City.belongs_to :country
+        Country.has_many :cities, -> { order :id }
+
+        stub_index(:countries) do
+          index_scope Country
+          field :id
+          field :cities do
+            field :id
+            field :name
+          end
+        end
+      end
+
+      let(:country_with_cities) do
+        cities = [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')]
+
+        Country.create!(id: 1, cities: cities)
+      end
+
       specify do
-        expect(CountriesIndex::Country.root_object.compose(country_with_cities)).to eq({
-          country: { 'id' => 1, 'cities' => [
-            { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
-          ] }
-        })
+        expect(CountriesIndex.root.compose(country_with_cities)).to eq('id' => 1, 'cities' => [
+          {'id' => 1, 'name' => 'City1'}, {'id' => 2, 'name' => 'City2'}
+        ])
       end
 
       context 'nested object' do
         before do
           stub_index(:cities) do
-            define_type City do
+            index_scope City
+            field :id
+            field :country do
               field :id
-              field :country do
-                field :id
-                field :name
-              end
+              field :name
             end
           end
         end
 
         specify do
-          expect(CitiesIndex::City.root_object.compose(
-            City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
-          )).to eq({
-            city: { 'id' => 1, 'country' => { 'id' => 1, 'name' => 'Country' } }
-          })
+          expect(
+            CitiesIndex.root.compose(City.create!(id: 1, country: Country.create!(id: 1, name: 'Country')))
+          ).to eq('id' => 1, 'country' => {'id' => 1, 'name' => 'Country'})
         end
       end
     end