chewy 0.1.0 → 0.2.0

data/spec/chewy/index/aliases_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Chewy::Index::Aliases do
+  include ClassHelpers
+  before { Chewy::Index.client.indices.delete }
+
+  before { stub_index :dummies }
+
+  describe '.indexes' do
+    specify { DummiesIndex.indexes.should == [] }
+
+    context do
+      before { DummiesIndex.create! }
+      specify { DummiesIndex.indexes.should == [] }
+    end
+
+    context do
+      before { DummiesIndex.create! }
+      before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
+      specify { DummiesIndex.indexes.should == [] }
+    end
+
+    context do
+      before { DummiesIndex.create! '2013' }
+      before { DummiesIndex.create! '2014' }
+      specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+    end
+  end
+
+  describe '.aliases' do
+    specify { DummiesIndex.aliases.should == [] }
+
+    context do
+      before { DummiesIndex.create! }
+      specify { DummiesIndex.aliases.should == [] }
+    end
+
+    context do
+      before { DummiesIndex.create! }
+      before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
+      before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2014' }
+      specify { DummiesIndex.aliases.should =~ ['dummies_2013', 'dummies_2014'] }
+    end
+
+    context do
+      before { DummiesIndex.create! '2013' }
+      specify { DummiesIndex.aliases.should == [] }
+    end
+  end
+end

data/spec/chewy/index_spec.rb

@@ -22,6 +22,21 @@ describe Chewy::Index do
     end
   end
 
+  describe '.define_type' do
+    specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
+
+    context do
+      before { stub_index(:dummies) { define_type :dummy, name: :borogoves } }
+      specify { DummiesIndex.type_hash['borogoves'].should == DummiesIndex::Borogoves }
+    end
+
+    context do
+      before { stub_model(:city) }
+      before { stub_index(:dummies) { define_type City, name: :country } }
+      specify { DummiesIndex.type_hash['country'].should == DummiesIndex::Country }
+    end
+  end
+
   describe '.type_hash' do
     specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
     specify { DummiesIndex.type_hash.should have_key 'dummy' }
@@ -42,6 +57,20 @@ describe Chewy::Index do
     specify { Class.new(Chewy::Index) { index_name :myindex }.index_name.should == 'myindex' }
     specify { stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name.should == 'developer' }
     specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name.should == 'developers' }
+
+    context do
+      before { Chewy.stub(client_options: {prefix: 'testing'}) }
+      specify { DummiesIndex.index_name.should == 'testing_dummies' }
+      specify { stub_index(:dummies) { index_name :users }.index_name.should == 'testing_users' }
+    end
+  end
+
+  describe '.build_index_name' do
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '').should == 'developers' }
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013').should == 'developers_2013' }
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '').should == 'developers' }
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test').should == 'test_developers' }
+    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013').should == 'test_users_2013' }
   end
 
   describe '.index_params' do
@@ -82,4 +111,39 @@ describe Chewy::Index do
       end
     end.mappings_hash[:mappings].keys.should =~ [:document, :document2] }
   end
+
+  describe '.import' do
+    before do
+      stub_model(:city)
+      stub_model(:country)
+
+      stub_index(:places) do
+        define_type City
+        define_type Country
+      end
+    end
+
+    let!(:cities) { 2.times.map { City.create! } }
+    let!(:countries) { 2.times.map { Country.create! } }
+
+    specify do
+      expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
+      expect { PlacesIndex.import }.to update_index(PlacesIndex::Country).and_reindex(countries)
+    end
+
+    specify do
+      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
+      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::Country).and_reindex(countries)
+    end
+
+    specify do
+      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
+      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::Country).and_reindex(countries.last).only
+    end
+
+    specify do
+      expect(PlacesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).twice
+      PlacesIndex.import city: cities.first, refresh: false
+    end
+  end
 end

data/spec/chewy/query/criteria_spec.rb

@@ -146,30 +146,30 @@ describe Chewy::Query::Criteria do
     }.should == {body: {query: :query, from: 10, sort: [:field], fields: ['field']}} }
   end
 
-  describe '#_request_query' do
-    def _request_query &block
+  describe '#_composed_query' do
+    def _composed_query &block
       subject.instance_exec(&block) if block
-      subject.send(:_request_query)
+      subject.send(:_composed_query, subject.send(:_request_query), subject.send(:_request_filter))
     end
 
-    specify { _request_query.should be_nil }
-    specify { _request_query { update_queries(:query) }.should == {query: :query} }
-    specify { _request_query { update_queries([:query1, :query2]) }
+    specify { _composed_query.should be_nil }
+    specify { _composed_query { update_queries(:query) }.should == {query: :query} }
+    specify { _composed_query { update_queries([:query1, :query2]) }
       .should == {query: {bool: {must: [:query1, :query2]}}} }
-    specify { _request_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
+    specify { _composed_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
       .should == {query: {bool: {should: [:query1, :query2]}}} }
-    specify { _request_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
+    specify { _composed_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
       .should == {query: {dis_max: {queries: [:query1, :query2]}}} }
 
-    specify { _request_query { update_filters([:filter1, :filter2]) }
+    specify { _composed_query { update_filters([:filter1, :filter2]) }
       .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}} }
-    specify { _request_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
+    specify { _composed_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
       .should == {query: {filtered: {
         query: {bool: {must: [:query1, :query2]}},
         filter: {and: [:filter1, :filter2]}
       }}}
     }
-    specify { _request_query {
+    specify { _composed_query {
         update_options(query_mode: :should); update_options(filter_mode: :or);
         update_filters([:filter1, :filter2]); update_queries([:query1, :query2])
       }.should == {query: {filtered: {

data/spec/chewy/query/{context_spec.rb → filters_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Query::Context do
+describe Chewy::Query::Filters do
   def Bool options
     Chewy::Query::Nodes::Bool.new.tap do |bool|
       bool.must(*options[:must]) if options[:must].present?
@@ -16,7 +16,7 @@ describe Chewy::Query::Context do
   end
 
   def query &block
-    Chewy::Query::Context.new(&block).__result__
+    Chewy::Query::Filters.new(&block).__result__
   end
 
   context 'outer scope' do

data/spec/chewy/query/loading_spec.rb

@@ -25,14 +25,16 @@ describe Chewy::Query::Loading do
     end
 
     before do
-      PlacesIndex.city.import(cities)
-      PlacesIndex.country.import(countries)
+      PlacesIndex::City.import(cities)
+      PlacesIndex::Country.import(countries)
     end
 
     specify { PlacesIndex.order(:rating).limit(6).load.total_count.should == 12 }
     specify { PlacesIndex.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
-    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->(i) { where('rating < 2') } })
+    specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } })
       .should =~ cities.first(2) + countries.first(3) + [nil] }
+    specify { PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') })
+      .should =~ cities.first(2) + countries.first(2) + [nil, nil] }
     specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') })
       .should =~ cities.first(2) + countries.first(3) + [nil] }
   end

data/spec/chewy/query/nodes/and_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::And do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { name? & (email == 'email') }.should == {

data/spec/chewy/query/nodes/bool_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Bool do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { must(name == 'name', email == 'email') }.should == {

data/spec/chewy/query/nodes/equal_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Equal do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { name == 'name' }.should == {term: {'name' => 'name'}} }

data/spec/chewy/query/nodes/exists_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Exists do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { name? }.should == {exists: {term: 'name'}} }

data/spec/chewy/query/nodes/has_child_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::HasChild do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Filters.new(&block).__render__
+    end
+
+    specify { render { has_child('child') }.should == {has_child: {type: 'child'}} }
+
+
+    specify { render { has_child('child').filter(term: {name: 'name'}) }
+      .should == {has_child: {type: 'child', filter: {term: {name: 'name'}}}} }
+    specify { render { has_child('child').filter{ name == 'name' } }
+      .should == {has_child: {type: 'child', filter: {term: {'name' => 'name'}}}} }
+    specify { render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 } }
+      .should == {has_child: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
+    specify { render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) }
+      .should == {has_child: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
+
+    specify { render { has_child('child').query(match: {name: 'name'}) }
+      .should == {has_child: {type: 'child', query: {match: {name: 'name'}}}} }
+    specify { render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) }
+      .should == {has_child: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
+    specify { render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) }
+      .should == {has_child: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
+
+    specify { render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}) }
+      .should == {has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}} }
+    specify { render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } }
+      .should == {has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}} }
+
+    context do
+      let(:name) { 'Name' }
+
+      specify { render { has_child('child').filter{ name == o{name} } }
+       .should == {has_child: {type: 'child', filter: {term: {'name' => 'Name'}}}} }
+    end
+  end
+end

data/spec/chewy/query/nodes/has_parent_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::HasParent do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Filters.new(&block).__render__
+    end
+
+    specify { render { has_parent('child') }.should == {has_parent: {type: 'child'}} }
+
+
+    specify { render { has_parent('child').filter(term: {name: 'name'}) }
+      .should == {has_parent: {type: 'child', filter: {term: {name: 'name'}}}} }
+    specify { render { has_parent('child').filter{ name == 'name' } }
+      .should == {has_parent: {type: 'child', filter: {term: {'name' => 'name'}}}} }
+    specify { render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 } }
+      .should == {has_parent: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
+    specify { render { has_parent('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) }
+      .should == {has_parent: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
+
+    specify { render { has_parent('child').query(match: {name: 'name'}) }
+      .should == {has_parent: {type: 'child', query: {match: {name: 'name'}}}} }
+    specify { render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) }
+      .should == {has_parent: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
+    specify { render { has_parent('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) }
+      .should == {has_parent: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
+
+    specify { render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}) }
+      .should == {has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}} }
+    specify { render { has_parent('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } }
+      .should == {has_parent: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}} }
+
+    context do
+      let(:name) { 'Name' }
+
+      specify { render { has_parent('child').filter{ name == o{name} } }
+       .should == {has_parent: {type: 'child', filter: {term: {'name' => 'Name'}}}} }
+    end
+  end
+end

data/spec/chewy/query/nodes/match_all_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::MatchAll do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Filters.new(&block).__render__
+    end
+
+    specify { render { match_all }.should == {match_all: {}} }
+  end
+end

data/spec/chewy/query/nodes/missing_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Missing do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { !name }.should == {missing: {term: 'name', existence: true, null_value: false}} }

data/spec/chewy/query/nodes/not_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Not do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { !(email == 'email') }.should == {

data/spec/chewy/query/nodes/or_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Or do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { name? | (email == 'email') }.should == {

data/spec/chewy/query/nodes/prefix_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Prefix do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { name =~ 'nam' }.should == {prefix: {'name' => 'nam'}} }

data/spec/chewy/query/nodes/query_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Query do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { q(query_string: {query: 'name: hello'}) }.should == {query: {query_string: {query: 'name: hello'}}} }

data/spec/chewy/query/nodes/range_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Range do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { age > nil }.should == {range: {'age' => {gt: nil}}} }

data/spec/chewy/query/nodes/raw_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Raw do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { r(term: {name: 'name'}) }.should == {term: {name: 'name'}} }

data/spec/chewy/query/nodes/regexp_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Regexp do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { names.first == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*'}} }

data/spec/chewy/query/nodes/script_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Query::Nodes::Script do
   describe '#__render__' do
     def render &block
-      Chewy::Query::Context.new(&block).__render__
+      Chewy::Query::Filters.new(&block).__render__
     end
 
     specify { render { s('var = val') }.should == {script: {script: 'var = val'}} }

data/spec/chewy/query/pagination_spec.rb

@@ -19,13 +19,13 @@ describe Chewy::Query::Pagination do
   let(:search) { ProductsIndex.order(:age) }
 
   describe '#per, #page' do
-    specify { search.map { |e| e.attributes.except('_score') }.should == data }
-    specify { search.page(1).map { |e| e.attributes.except('_score') }.should == data[0..2] }
-    specify { search.page(2).map { |e| e.attributes.except('_score') }.should == data[3..5] }
-    specify { search.page(2).per(4).map { |e| e.attributes.except('_score') }.should == data[4..7] }
-    specify { search.per(2).page(3).map { |e| e.attributes.except('_score') }.should == data[4..5] }
-    specify { search.per(5).page.map { |e| e.attributes.except('_score') }.should == data[0..4] }
-    specify { search.page.per(4).map { |e| e.attributes.except('_score') }.should == data[0..3] }
+    specify { search.map { |e| e.attributes.except('_score', '_explanation') }.should == data }
+    specify { search.page(1).map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..2] }
+    specify { search.page(2).map { |e| e.attributes.except('_score', '_explanation') }.should == data[3..5] }
+    specify { search.page(2).per(4).map { |e| e.attributes.except('_score', '_explanation') }.should == data[4..7] }
+    specify { search.per(2).page(3).map { |e| e.attributes.except('_score', '_explanation') }.should == data[4..5] }
+    specify { search.per(5).page.map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..4] }
+    specify { search.page.per(4).map { |e| e.attributes.except('_score', '_explanation') }.should == data[0..3] }
   end
 
   describe '#total_pages' do