chewy 0.8.4 → 0.9.0

data/spec/chewy/config_spec.rb

@@ -12,28 +12,49 @@ describe Chewy::Config do
   its(:root_strategy) { should == :base }
   its(:request_strategy) { should == :atomic }
   its(:use_after_commit_callbacks) { should == true }
+  its(:indices_path) { should == 'app/chewy' }
 
   describe '#transport_logger=' do
     let(:logger) { Logger.new('/dev/null') }
     after { subject.transport_logger = nil }
 
-    specify { expect { subject.transport_logger = logger }
-      .to change { Chewy.client.transport.logger }.to(logger) }
-    specify { expect { subject.transport_logger = logger }
-      .to change { subject.transport_logger }.to(logger) }
-    specify { expect { subject.transport_logger = logger }
-      .to change { subject.configuration[:logger] }.from(nil).to(logger) }
+    specify do
+      expect { subject.transport_logger = logger }
+        .to change { Chewy.client.transport.logger }.to(logger)
+    end
+    specify do
+      expect { subject.transport_logger = logger }
+        .to change { subject.transport_logger }.to(logger)
+    end
+    specify do
+      expect { subject.transport_logger = logger }
+        .to change { subject.configuration[:logger] }.from(nil).to(logger)
+    end
   end
 
   describe '#transport_tracer=' do
     let(:tracer) { Logger.new('/dev/null') }
     after { subject.transport_tracer = nil }
 
-    specify { expect { subject.transport_tracer = tracer }
-      .to change { Chewy.client.transport.tracer }.to(tracer) }
-    specify { expect { subject.transport_tracer = tracer }
-      .to change { subject.transport_tracer }.to(tracer) }
-    specify { expect { subject.transport_tracer = tracer }
-      .to change { subject.configuration[:tracer] }.from(nil).to(tracer) }
+    specify do
+      expect { subject.transport_tracer = tracer }
+        .to change { Chewy.client.transport.tracer }.to(tracer)
+    end
+    specify do
+      expect { subject.transport_tracer = tracer }
+        .to change { subject.transport_tracer }.to(tracer)
+    end
+    specify do
+      expect { subject.transport_tracer = tracer }
+        .to change { subject.configuration[:tracer] }.from(nil).to(tracer)
+    end
+  end
+
+  describe '#configuration' do
+    before { subject.settings = { indices_path: 'app/custom_indices_path' } }
+
+    specify do
+      expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')
+    end
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -5,37 +5,40 @@ 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 { 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!(: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] }) }
 
@@ -44,14 +47,16 @@ describe Chewy::Fields::Base do
         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(name: 'Bangkok', districts: %w(First Second))
+        ]))).to eq(name: [
+          { name: [
+            { name: [%w(First Thailand), 'Bangkok', 'Thailand'] },
+            { name: [%w(Second Thailand), 'Bangkok', 'Thailand'] }
+          ] }
+        ])
+      end
     end
 
     context 'implicit values' do
@@ -61,46 +66,50 @@ describe Chewy::Fields::Base do
         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: "string#{i + 1}") } }
+    let(:fields2) { Array.new(2) { |i| described_class.new("name#{i + 3}", type: "string#{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: 'string1', fields: {
+                                            name3: { type: 'string3' }, name4: { type: 'string4' }
+                                          } }, name2: { type: 'string2' }
+                                        } })
+    end
 
     context do
       let(:field) { described_class.new(:name, type: :string) }
-      let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}") } }
+      let(:fields1) { Array.new(2) { |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'}
-      }}}) }
+      specify do
+        expect(field.mappings_hash).to eq(name: { type: :string, fields: {
+                                            name1: { type: 'object', properties: {
+                                              name3: { type: 'string3' }, name4: { type: 'string4' }
+                                            } }, name2: { type: 'string' }
+                                          } })
+      end
     end
   end
 
@@ -122,48 +131,48 @@ describe Chewy::Fields::Base do
       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' } } } } } } } })
+        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' }
+                                                                 }
+                                                               }
+                                                             }
+                                                           }
+                                                         }
+                                                       })
       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'}}}
-        })
+                 id: 1, category: { id: 2, licenses: { id: 3, name: 'Name' } }
+        )).to eq('event' => { '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, licenses: nil}
-        ])).to eq({
-          event: { 'id' => 1, 'category' => [
-            { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-            {'id' => 4, 'licenses' => nil.as_json }
-          ] }
-        })
+          { id: 4, licenses: nil }
+        ])).to eq('event' => { '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('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'}
-          ] } }
-        })
+        ] })).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
+          { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
+        ] } })
       end
 
       specify do
@@ -172,44 +181,36 @@ describe Chewy::Fields::Base do
             { 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' => [] }
-          ] }
-        })
+        ])).to eq('event' => { 'id' => 1, 'category' => [
+          { 'id' => 2, 'licenses' => [
+            { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
+          ] },
+          { 'id' => 5, 'licenses' => [] }
+        ] })
       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'}}}
-        })
+                 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' } } })
       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 }
-          ] }
-        })
+        ]))).to eq('event' => { '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: 'Name1'), double(id: 4, name: 'Name2')
-        ])))).to eq({
-          event: { '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' }
+        ] } })
       end
 
       specify do
@@ -218,14 +219,12 @@ describe Chewy::Fields::Base do
             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('event' => { 'id' => 1, 'category' => [
+          { 'id' => 2, 'licenses' => [
+            { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
+          ] },
+          { 'id' => 5, 'licenses' => [] }
+        ] })
       end
     end
 
@@ -234,9 +233,9 @@ describe Chewy::Fields::Base do
         stub_index(:events) do
           define_type :event do
             field :id
-            field :category, value: ->{ categories } do
+            field :category, value: -> { categories } do
               field :id
-              field :licenses, value: ->{ license } do
+              field :licenses, value: -> { license } do
                 field :id
                 field :name
               end
@@ -247,10 +246,8 @@ describe Chewy::Fields::Base do
 
       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'}}}
-        })
+                 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' } } })
       end
     end
 
@@ -268,48 +265,44 @@ describe Chewy::Fields::Base do
       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::Event.mappings_hash).to eq(event: {
+                                                         properties: {
+                                                           id: { type: 'string' },
+                                                           name: {
+                                                             type: 'string',
+                                                             fields: {
+                                                               raw: { analyzer: 'my_own', type: 'string' }
+                                                             }
+                                                           },
+                                                           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' }
-          }
-        })
+                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: { 'name' => 'Borogoves' }))
+        )).to eq('event' => {
+                   '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' }
-            ]
-          }
-        })
+                 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' }
+                   ]
+                 })
       end
     end
 
@@ -358,11 +351,9 @@ describe Chewy::Fields::Base do
       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::Country.root_object.compose(country_with_cities)).to eq('country' => { 'id' => 1, 'cities' => [
+          { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
+        ] })
       end
 
       context 'nested object' do
@@ -380,10 +371,8 @@ describe Chewy::Fields::Base do
 
         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' } }
-          })
+                   City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
+          )).to eq('city' => { 'id' => 1, 'country' => { 'id' => 1, 'name' => 'Country' } })
         end
       end
     end