chewy 0.0.1

data/spec/chewy/query/loading_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Chewy::Query::Loading do
+  include ClassHelpers
+  before { Chewy::Index.client.indices.delete }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+  end
+
+  context 'multiple types' do
+    let(:cities) { 6.times.map { |i| City.create!(rating: i) } }
+    let(:countries) { 6.times.map { |i| Country.create!(rating: i) } }
+
+    before do
+      stub_index(:places) do
+        define_type City do
+          field :rating, type: 'number', value: ->(o){ o.rating }
+        end
+        define_type Country do
+          field :rating, type: 'number', value: ->(o){ o.rating }
+        end
+      end
+    end
+
+    before do
+      PlacesIndex.city.import(cities)
+      PlacesIndex.country.import(countries)
+    end
+
+    specify { PlacesIndex.search.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
+    specify { PlacesIndex.search.order(:rating).limit(6).load(scopes: {city: ->(i){ where('rating < 2') }})
+      .should =~ cities.first(2) + countries.first(3) }
+    specify { PlacesIndex.search.order(:rating).limit(6).load.total_count.should == 12 }
+  end
+end

data/spec/chewy/query/pagination_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Chewy::Query::Pagination do
+  include ClassHelpers
+
+  before do
+    stub_index(:products) do
+      define_type(:product) do
+        field :name, :age
+      end
+    end
+  end
+  let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+
+  before { ProductsIndex.types['product'].import(data.map { |h| double(h) }) }
+  before { Kaminari.config.stub(default_per_page: 3) }
+
+  let(:search) { ProductsIndex.search.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] }
+  end
+
+  describe '#total_pages' do
+    specify { search.total_pages.should == 4 }
+    specify { search.per(5).page(2).total_pages.should == 2 }
+    specify { search.per(2).page(3).total_pages.should == 5 }
+  end
+
+  describe '#total_count' do
+    specify { search.per(4).page(1).total_count.should == 10 }
+    specify { search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count.should == 8 }
+  end
+end

data/spec/chewy/query_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Chewy::Query do
+  include ClassHelpers
+
+  before do
+    stub_index(:products) do
+      define_type :product do
+        field :name, :age
+      end
+    end
+  end
+
+  subject { described_class.new(ProductsIndex, type: :product) }
+
+  describe '#==' do
+    let(:data) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    before { ProductsIndex.types['product'].import(data.map { |h| double(h) }) }
+
+    specify { subject.query(match: 'hello').should == subject.query(match: 'hello') }
+    specify { subject.query(match: 'hello').should_not == subject.query(match: 'world') }
+    specify { subject.limit(10).should == subject.limit(10) }
+    specify { subject.limit(10).should_not == subject.limit(11) }
+    specify { subject.limit(2).should == subject.limit(2).to_a }
+  end
+
+  describe '#_request_query' do
+    specify { subject.send(:_request_query).should == {} }
+    specify { subject.filter(term: {field: 'hello'}).send(:_request_query)
+      .should == {query: {filtered: {query: {match_all: {}}, filter: {term: {field: "hello"}}}}} }
+    specify { subject.filter(term: {field: 'hello'}).filter(term: {field: 'world'}).send(:_request_query)
+      .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [
+        {term: {field: "hello"}}, {term: {field: "world"}}
+      ]}}}} }
+    specify { subject.query(term: {field: 'hello'}).send(:_request_query)
+      .should == {query: {term: {field: "hello"}}} }
+    specify { subject.filter(term: {field: 'hello'}).query(term: {field: 'world'}).send(:_request_query)
+      .should == {query: {filtered: {query: {term: {field: "world"}}, filter: {term: {field: "hello"}}}}} }
+  end
+
+  describe '#limit' do
+    specify { subject.limit(10).should be_a described_class }
+    specify { subject.limit(10).should_not == subject }
+    specify { subject.limit(10).criteria.search.should include(size: 10) }
+    specify { expect { subject.limit(10) }.not_to change { subject.criteria.search } }
+  end
+
+  describe '#offset' do
+    specify { subject.offset(10).should be_a described_class }
+    specify { subject.offset(10).should_not == subject }
+    specify { subject.offset(10).criteria.search.should include(from: 10) }
+    specify { expect { subject.offset(10) }.not_to change { subject.criteria.search } }
+  end
+
+  describe '#query' do
+    specify { subject.query(match: 'hello').should be_a described_class }
+    specify { subject.query(match: 'hello').should_not == subject }
+    specify { subject.query(match: 'hello').criteria.query.should include(match: 'hello') }
+    specify { expect { subject.query(match: 'hello') }.not_to change { subject.criteria.query } }
+  end
+
+  describe '#facets' do
+    specify { subject.facets(term: {field: 'hello'}).should be_a described_class }
+    specify { subject.facets(term: {field: 'hello'}).should_not == subject }
+    specify { subject.facets(term: {field: 'hello'}).criteria.facets.should include(term: {field: 'hello'}) }
+    specify { expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets } }
+  end
+
+  describe '#filter' do
+    specify { subject.filter(term: {field: 'hello'}).should be_a described_class }
+    specify { subject.filter(term: {field: 'hello'}).should_not == subject }
+    specify { subject.filter(term: {field: 'hello'}).criteria.filters.should include(term: {field: 'hello'}) }
+    specify { subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters.should include(term: {field: 'hello'}) }
+    specify { subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters.should include(term: {field: 'world'}) }
+    specify { expect { subject.filter(term: {field: 'hello'}) }.not_to change { subject.criteria.filters } }
+  end
+
+  describe '#order' do
+    specify { subject.order(field: 'hello').should be_a described_class }
+    specify { subject.order(field: 'hello').should_not == subject }
+    specify { subject.order(field: 'hello').criteria.sort.should include(field: 'hello') }
+    specify { expect { subject.order(field: 'hello') }.not_to change { subject.criteria.sort } }
+
+    specify { subject.order(:field).criteria.sort.should == [:field] }
+    specify { subject.order([:field1, :field2]).criteria.sort.should == [:field1, :field2] }
+    specify { subject.order(field: :asc).criteria.sort.should == [{field: :asc}] }
+    specify { subject.order({field1: {order: :asc}, field2: :desc}).order([:field3], :field4).criteria.sort.should == [{field1: {order: :asc}}, {field2: :desc}, :field3, :field4] }
+  end
+
+  describe '#reorder' do
+    specify { subject.reorder(field: 'hello').should be_a described_class }
+    specify { subject.reorder(field: 'hello').should_not == subject }
+    specify { subject.reorder(field: 'hello').criteria.sort.should include(field: 'hello') }
+    specify { expect { subject.reorder(field: 'hello') }.not_to change { subject.criteria.sort } }
+
+    specify { subject.order(:field1).reorder(:field2).criteria.sort.should == [:field2] }
+    specify { subject.order(:field1).reorder(:field2).order(:field3).criteria.sort.should == [:field2, :field3] }
+    specify { subject.order(:field1).reorder(:field2).reorder(:field3).criteria.sort.should == [:field3] }
+  end
+
+  describe '#only' do
+    specify { subject.only(:field).should be_a described_class }
+    specify { subject.only(:field).should_not == subject }
+    specify { subject.only(:field).criteria.fields.should include('field') }
+    specify { expect { subject.only(:field) }.not_to change { subject.criteria.fields } }
+
+    specify { subject.only(:field1, :field2).criteria.fields.should =~ ['field1', 'field2'] }
+    specify { subject.only([:field1, :field2]).only(:field3).criteria.fields.should =~ ['field1', 'field2', 'field3'] }
+  end
+end

data/spec/chewy/rspec/update_index_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe :update_index do
+  include ClassHelpers
+  before { Chewy::Index.client.indices.delete }
+
+  before do
+    stub_index(:dummies) do
+      define_type :dummy do
+        root value: ->(o){{}}
+      end
+    end
+  end
+
+  specify { expect {  }.not_to update_index(DummiesIndex.dummy) }
+  specify { expect { DummiesIndex.dummy.bulk body: [] }.not_to update_index(DummiesIndex.dummy) }
+
+  specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex.dummy) }
+    .to fail_with(/Expected index .* not to be updated, but it was with/) }
+
+  context do
+    let(:expectation) do
+      expect { expect {
+        DummiesIndex.dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
+      }.not_to update_index(DummiesIndex.dummy) }
+    end
+
+    specify { expectation.to fail_matching 'document id `42` (2 times)' }
+    specify { expectation.to fail_matching 'document id `41` (1 times)' }
+  end
+
+  context '#and_reindex' do
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex.dummy) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(42) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(double(id: 42)) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(double(id: 42), double(id: 43)) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex([double(id: 42), 43]) }
+
+    specify do
+      expect {
+        expect {
+          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        }.to update_index(DummiesIndex.dummy).and_reindex([44, 43])
+      }.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
+    end
+
+    context do
+      let(:expectation) do
+        expect { expect {
+          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        }.to update_index(DummiesIndex.dummy).and_reindex(44, double(id: 47)) }
+      end
+
+      specify { expectation.to fail_matching('Expected document with id `44` to be reindexed, but it was not') }
+      specify { expectation.to fail_matching('Expected document with id `47` to be reindexed, but it was not') }
+    end
+
+    context ':times' do
+      specify { expect {
+        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+      }.to update_index(DummiesIndex.dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) }
+
+      specify { expect {
+        expect {
+          DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+        }.to update_index(DummiesIndex.dummy).and_reindex(42, times: 3)
+      }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
+
+      context do
+        let(:expectation) do
+          expect { expect {
+            DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+            DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+          }.to update_index(DummiesIndex.dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) }
+        end
+
+        specify { expectation.to fail_matching 'Expected document with id `44` to be reindexed' }
+        specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
+        specify { expectation.to fail_matching '3 times, but was reindexed 1 times' }
+        specify { expectation.to fail_matching '4 times, but was reindexed 2 times' }
+      end
+    end
+
+    context ':with' do
+      specify { expect {
+        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+      }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: 2}) }
+
+      specify { expect {
+        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
+      }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: '1', b: 2}) }
+
+      specify { expect {
+        expect {
+          DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+        }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: 1})
+      }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
+
+      context do
+        let(:expectation) do
+          expect { expect {
+            DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+          }.to update_index(DummiesIndex.dummy).and_reindex(43, times: 2, with: {a: 2}) }
+        end
+
+        specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
+        specify { expectation.to fail_matching '2 times, but was reindexed 1 times' }
+        specify { expectation.to fail_matching 'with {:a=>2}, but it was reindexed with {:a=>"1"}' }
+      end
+    end
+  end
+
+  context '#and_delete' do
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(42).and_delete(double(id: 43)) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex.dummy).and_delete(42).and_delete(double(id: 43)) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex.dummy).and_delete(42, double(id: 43)) }
+    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex.dummy).and_delete([43, double(id: 42)]) }
+
+    context do
+      let(:expectation) do
+        expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+          .to update_index(DummiesIndex.dummy).and_reindex(43).and_delete(double(id: 42)) }
+      end
+
+      specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed, but it was not' }
+      specify { expectation.to fail_matching 'Expected document with id `42` to be deleted, but it was not' }
+    end
+
+    context do
+      let(:expectation) do
+        expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
+          .to update_index(DummiesIndex.dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3) }
+      end
+
+      specify { expectation.to fail_matching 'Expected document with id `44` to be deleted, but it was not' }
+      specify { expectation.to fail_matching 'Expected document with id `42` to be deleted' }
+      specify { expectation.to fail_matching '3 times, but was deleted 2 times' }
+    end
+  end
+end

data/spec/chewy/type/import_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Chewy::Type::Import do
+  include ClassHelpers
+
+  before do
+    stub_model(:city)
+  end
+
+  before do
+    stub_index(:cities) do
+      define_type City do
+        field :name
+      end
+    end
+  end
+
+  let!(:dummy_cities) { 3.times.map { |i| City.create(name: "name#{i}") } }
+  let(:city) { CitiesIndex::City }
+
+  describe '.import' do
+    specify { expect { city.import([]) }.not_to update_index(city) }
+    specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities) }
+    specify { expect { city.import dummy_cities }.to update_index(city).and_reindex(dummy_cities) }
+    specify { expect { city.import dummy_cities.map(&:id) }.to update_index(city).and_reindex(dummy_cities) }
+    specify { expect { city.import(City.where(name: ['name0', 'name1'])) }
+      .to update_index(city).and_reindex(dummy_cities.first(2)) }
+    specify { expect { city.import(City.where(name: ['name0', 'name1']).map(&:id)) }
+        .to update_index(city).and_reindex(dummy_cities.first(2)) }
+
+    specify do
+      dummy_cities.first.destroy
+      expect { city.import dummy_cities }
+        .to update_index(city).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
+    end
+
+    specify do
+      dummy_cities.first.destroy
+      expect { city.import dummy_cities.map(&:id) }
+        .to update_index(city).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
+    end
+
+    specify do
+      dummy_cities.first.destroy
+      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
+        body: [{delete: {_index: 'cities', _type: 'city', _id: dummy_cities.first.id}}]
+      ))
+      dummy_cities.from(1).each.with_index do |c, i|
+        expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
+          body: [{index: {_id: c.id, _index: 'cities', _type: 'city', data: {'name' => "name#{i+1}"}}}]
+        ))
+      end
+      city.import dummy_cities.map(&:id), batch_size: 1
+    end
+
+    context 'scoped' do
+      before do
+        stub_index(:cities) do
+          define_type City.where(name: ['name0', 'name1']) do
+            field :name
+          end
+        end
+      end
+
+      specify { expect { CitiesIndex.import }.to update_index(city).and_reindex(dummy_cities.first(2)) }
+    end
+  end
+end

data/spec/chewy/type/mapping_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Chewy::Type::Mapping do
+  include ClassHelpers
+
+  let(:product) { ProductsIndex.product }
+
+  before do
+    stub_index(:products) do
+      define_type :product do
+        root do
+          field :name, 'surname'
+          field :title, type: 'string' do
+            field :subfield1
+          end
+          field 'price', type: 'float' do
+            field :subfield2
+          end
+        end
+      end
+    end
+  end
+
+  describe '.field' do
+    specify { product.root_object.nested.keys.should =~ [:name, :surname, :title, :price] }
+    specify { product.root_object.nested.values.should satisfy { |v| v.all? { |f| f.is_a? Chewy::Fields::Default } } }
+
+    specify { product.root_object.nested[:title].nested.keys.should == [:subfield1] }
+    specify { product.root_object.nested[:title].nested[:subfield1].should be_a Chewy::Fields::Default }
+
+    specify { product.root_object.nested[:price].nested.keys.should == [:subfield2] }
+    specify { product.root_object.nested[:price].nested[:subfield2].should be_a Chewy::Fields::Default }
+  end
+
+  describe '.mappings_hash' do
+    specify { Class.new(Chewy::Type::Base).mappings_hash.should == {} }
+    specify { product.mappings_hash.should == product.root_object.mappings_hash }
+  end
+
+  context "no root element call" do
+    before do
+      stub_index(:products) do
+        define_type :product do
+          field :title, type: 'string' do
+            field :subfield1
+          end
+        end
+      end
+    end
+
+    specify { product.root_object.nested[:title].nested.keys.should == [:subfield1] }
+    specify { product.root_object.nested[:title].nested[:subfield1].should be_a Chewy::Fields::Default }
+  end
+end