chewy 0.0.1 → 0.1.0

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Range do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { age > nil }.should == {range: {'age' => {gt: nil}}} }
+    specify { render { age == (nil..nil) }.should == {range: {'age' => {gt: nil, lt: nil}}} }
+
+    specify { render { age > 42 }.should == {range: {'age' => {gt: 42}}} }
+    specify { render { age == (42..45) }.should == {range: {'age' => {gt: 42, lt: 45}}} }
+    specify { render { age == [42..45] }.should == {range: {'age' => {gte: 42, lte: 45}}} }
+    specify { render { (age > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}}} }
+
+    specify { render { ~age > 42 }.should == {range: {'age' => {gt: 42}, _cache: true}} }
+    specify { render { ~age == (42..45) }.should == {range: {'age' => {gt: 42, lt: 45}, _cache: true}} }
+    specify { render { ~age == [42..45] }.should == {range: {'age' => {gte: 42, lte: 45}, _cache: true}} }
+    specify { render { (age > 42) & ~(age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, _cache: true}} }
+    specify { render { (~age > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, _cache: true}} }
+
+    specify { render { age(:i) > 42 }.should == {range: {'age' => {gt: 42}, execution: :index}} }
+    specify { render { age(:index) > 42 }.should == {range: {'age' => {gt: 42}, execution: :index}} }
+    specify { render { age(:f) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata}} }
+    specify { render { age(:fielddata) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata}} }
+    specify { render { (age(:f) > 42) & (age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, execution: :fielddata}} }
+
+    specify { render { ~age(:f) > 42 }.should == {range: {'age' => {gt: 42}, execution: :fielddata, _cache: true}} }
+    specify { render { (age(:f) > 42) & (~age <= 45) }.should == {range: {'age' => {gt: 42, lte: 45}, execution: :fielddata, _cache: true}} }
+  end
+end

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

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

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Regexp do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { names.first == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*'}} }
+    specify { render { names.first =~ /nam.*/ }.should == {regexp: {'names.first' => 'nam.*'}} }
+    specify { render { name != /nam.*/ }.should == {not: {regexp: {'name' => 'nam.*'}}} }
+    specify { render { name !~ /nam.*/ }.should == {not: {regexp: {'name' => 'nam.*'}}} }
+
+    specify { render { names.first(flags: [:anystring, :intersection, :borogoves]) == /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+    specify { render { names.first(:anystring, :intersection, :borogoves) == /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+
+    specify { render { names.first(flags: [:anystring, :intersection, :borogoves]) =~ /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+    specify { render { names.first(:anystring, :intersection, :borogoves) =~ /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING|INTERSECTION'}}} }
+
+    specify { render { ~names.first == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'nam.*'}} }
+    specify { render { names.first(cache: 'name') == /nam.*/ }.should == {regexp: {'names.first' => 'nam.*', _cache: true, _cache_key: 'name'}} }
+    specify { render { ~names.first(:anystring) =~ /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'nam.*'}} }
+    specify { render { names.first(:anystring, cache: 'name') =~ /nam.*/ }
+      .should == {regexp: {'names.first' => {value: 'nam.*', flags: 'ANYSTRING'}, _cache: true, _cache_key: 'name'}} }
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Chewy::Query::Nodes::Script do
+  describe '#__render__' do
+    def render &block
+      Chewy::Query::Context.new(&block).__render__
+    end
+
+    specify { render { s('var = val') }.should == {script: {script: 'var = val'}} }
+    specify { render { s('var = val', val: 42) }.should == {script: {script: 'var = val', params: {val: 42}}} }
+
+    specify { render { ~s('var = val') }.should == {script: {script: 'var = val', _cache: true}} }
+    specify { render { ~s('var = val', val: 42) }.should == {script: {script: 'var = val', params: {val: 42}, _cache: true}} }
+  end
+end

data/spec/chewy/query/pagination_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Chewy::Query::Pagination do
   include ClassHelpers
+  before { Chewy::Index.client.indices.delete }
 
   before do
     stub_index(:products) do
@@ -12,10 +13,10 @@ describe Chewy::Query::Pagination do
   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 { ProductsIndex::Product.import(data.map { |h| double(h) }) }
   before { Kaminari.config.stub(default_per_page: 3) }
 
-  let(:search) { ProductsIndex.search.order(:age) }
+  let(:search) { ProductsIndex.order(:age) }
 
   describe '#per, #page' do
     specify { search.map { |e| e.attributes.except('_score') }.should == data }

data/spec/chewy/query_spec.rb

@@ -3,19 +3,39 @@ require 'spec_helper'
 describe Chewy::Query do
   include ClassHelpers
 
+  before { Chewy::Index.client.indices.delete }
   before do
     stub_index(:products) do
       define_type :product do
         field :name, :age
       end
+      define_type :city
+      define_type :country
     end
   end
 
-  subject { described_class.new(ProductsIndex, type: :product) }
+  subject { described_class.new(ProductsIndex) }
+
+  context 'integration' do
+    let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    let(:cities) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+    let(:countries) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+    before { ProductsIndex::Product.import(products.map { |h| double(h) }) }
+    before { ProductsIndex::City.import(cities.map { |h| double(h) }) }
+    before { ProductsIndex::Country.import(countries.map { |h| double(h) }) }
+
+    specify { subject.count.should == 9 }
+    specify { subject.limit(6).count.should == 6 }
+    specify { subject.offset(6).count.should == 3 }
+    specify { subject.types(:product).count.should == 3 }
+    specify { subject.types(:product, :country).count.should == 6 }
+    specify { subject.filter(term: {age: 10}).count.should == 1 }
+    specify { subject.query(term: {age: 10}).count.should == 1 }
+  end
 
   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) }) }
+    before { ProductsIndex::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') }
@@ -24,39 +44,39 @@ describe Chewy::Query do
     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"}}}}} }
+  describe '#query_mode' do
+    specify { subject.query_mode(:should).should be_a described_class }
+    specify { subject.query_mode(:should).should_not == subject }
+    specify { subject.query_mode(:should).criteria.options.should include(query_mode: :should) }
+    specify { expect { subject.query_mode(:should) }.not_to change { subject.criteria.options } }
+  end
+
+  describe '#filter_mode' do
+    specify { subject.filter_mode(:or).should be_a described_class }
+    specify { subject.filter_mode(:or).should_not == subject }
+    specify { subject.filter_mode(:or).criteria.options.should include(filter_mode: :or) }
+    specify { expect { subject.filter_mode(:or) }.not_to change { subject.criteria.options } }
   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 } }
+    specify { subject.limit(10).criteria.options.should include(size: 10) }
+    specify { expect { subject.limit(10) }.not_to change { subject.criteria.options } }
   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 } }
+    specify { subject.offset(10).criteria.options.should include(from: 10) }
+    specify { expect { subject.offset(10) }.not_to change { subject.criteria.options } }
   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 } }
+    specify { subject.query(match: 'hello').criteria.queries.should include(match: 'hello') }
+    specify { expect { subject.query(match: 'hello') }.not_to change { subject.criteria.queries } }
   end
 
   describe '#facets' do
@@ -69,16 +89,17 @@ describe Chewy::Query do
   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 } }
+    specify { subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters
+      .should == [{term: {field: 'hello'}}, {term: {field: 'world'}}] }
+
+    specify { expect { subject.filter{ name == 'John' } }.not_to change { subject.criteria.filters } }
+    specify { subject.filter{ name == 'John' }.criteria.filters.should == [{term: {'name' => 'John'}}] }
   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] }
@@ -90,7 +111,6 @@ describe Chewy::Query do
   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] }
@@ -101,10 +121,47 @@ describe Chewy::Query do
   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
+
+  describe '#only!' do
+    specify { subject.only!(:field).should be_a described_class }
+    specify { subject.only!(:field).should_not == subject }
+    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 =~ ['field3'] }
+    specify { subject.only([:field1, :field2]).only!(:field3).criteria.fields.should =~ ['field3'] }
+  end
+
+  describe '#types' do
+    specify { subject.types(:product).should be_a described_class }
+    specify { subject.types(:product).should_not == subject }
+    specify { expect { subject.types(:product) }.not_to change { subject.criteria.types } }
+
+    specify { subject.types(:user).criteria.types.should == ['user'] }
+    specify { subject.types(:product, :city).criteria.types.should =~ ['product', 'city'] }
+    specify { subject.types([:product, :city]).types(:country).criteria.types.should =~ ['product', 'city', 'country'] }
+  end
+
+  describe '#types!' do
+    specify { subject.types!(:product).should be_a described_class }
+    specify { subject.types!(:product).should_not == subject }
+    specify { expect { subject.types!(:product) }.not_to change { subject.criteria.types } }
+
+    specify { subject.types!(:user).criteria.types.should == ['user'] }
+    specify { subject.types!(:product, :city).criteria.types.should =~ ['product', 'city'] }
+    specify { subject.types!([:product, :city]).types!(:country).criteria.types.should =~ ['country'] }
+    specify { subject.types([:product, :city]).types!(:country).criteria.types.should =~ ['country'] }
+  end
+
+  describe '#merge' do
+    let(:query) { described_class.new(ProductsIndex) }
+
+    specify { subject.filter { name == 'name' }.merge(query.filter { age == 42 }).criteria.filters
+      .should == [{term: {'name' => 'name'}}, {term: {'age' => 42}}] }
+  end
 end

data/spec/chewy/rspec/update_index_spec.rb

@@ -29,6 +29,26 @@ describe :update_index do
     specify { expectation.to fail_matching 'document id `41` (1 times)' }
   end
 
+  context '#only' do
+    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(41, 42).only }
+    specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(41).only }
+        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
+    specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex.dummy).and_reindex(41, times: 2).only }
+        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
+
+    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex.dummy).and_delete(41, 42).only }
+    specify { expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex.dummy).and_delete(41).only }
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
+    specify { expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex.dummy).and_delete(41, times: 2).only }
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
+  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: {}}}] }

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Chewy::Type::Adapter::ActiveRecord do
+  before { stub_model(:city) }
+
+  describe '#name' do
+    specify { described_class.new(City).name.should == 'City' }
+    specify { described_class.new(City.order(:id)).name.should == 'City' }
+    specify { described_class.new(City, name: 'town').name.should == 'Town' }
+  end
+
+  describe '#type_name' do
+    specify { described_class.new(City).type_name.should == 'city' }
+    specify { described_class.new(City.order(:id)).type_name.should == 'city' }
+    specify { described_class.new(City, name: 'town').type_name.should == 'town' }
+  end
+
+  describe '#import' do
+    def import(*args)
+      result = []
+      subject.import(*args) { |data| result.push data }
+      result
+    end
+
+    specify { subject.import(3.times.map { |i| City.create! }) { |data| true }.should be_true }
+    specify { subject.import(3.times.map { |i| City.create! }) { |data| false }.should be_false }
+
+    context do
+      let!(:cities) { 3.times.map { |i| City.create! } }
+      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy!) } }
+      subject { described_class.new(City) }
+
+      specify { import.should == [{index: cities}] }
+
+      specify { import(City.order(:id)).should == [{index: cities}] }
+      specify { import(City.order(:id), batch_size: 2)
+        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+
+      specify { import(cities).should == [{index: cities}] }
+      specify { import(cities, batch_size: 2)
+          .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
+      specify { import(cities, deleted, batch_size: 2).should == [
+          {index: cities.first(2)},
+          {index: cities.last(1), delete: deleted.first(1)},
+          {delete: deleted.last(2)}] }
+
+      specify { import(cities.map(&:id)).should == [{index: cities}] }
+      specify { import(cities.map(&:id), batch_size: 2)
+        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { import(cities.map(&:id), deleted.map(&:id))
+        .should == [{index: cities}, {delete: deleted.map(&:id)}] }
+      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
+        {index: cities.first(2)},
+        {index: cities.last(1)},
+        {delete: deleted.first(2).map(&:id)},
+        {delete: deleted.last(1).map(&:id)}] }
+    end
+
+    context do
+      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy!) } }
+      subject { described_class.new(City.where(country_id: 0)) }
+
+      specify { import.should == [{index: cities.first(2)}] }
+
+      specify { import(City.order(:id)).should == [{index: cities.first(2)}] }
+      specify { import(City.order(:id), batch_size: 1)
+        .should == [{index: [cities.first]}, {index: [cities.second]}] }
+
+      specify { import(cities).should == [{index: cities}] }
+      specify { import(cities, batch_size: 2)
+        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+
+      specify { import(cities.map(&:id))
+        .should == [{index: cities.first(2)}, {delete: [cities.last.id]}] }
+      specify { import(cities.map(&:id), batch_size: 1)
+        .should == [{index: [cities.first]}, {index: [cities.second]}, {delete: [cities.last.id]}] }
+      specify { import(cities.map(&:id), deleted.map(&:id))
+        .should == [{index: cities.first(2)}, {delete: [cities.last.id] + deleted.map(&:id)}] }
+      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
+        {index: cities.first(2)},
+        {delete: [cities.last.id] + deleted.first(1).map(&:id)},
+        {delete: deleted.last(1).map(&:id)}] }
+    end
+  end
+
+  describe '#load' do
+    let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
+    let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy!) } }
+    subject { described_class.new(City) }
+
+    specify { subject.load(cities.map { |c| double(id: c.id) }).should == cities }
+    specify { subject.load(cities.map { |c| double(id: c.id) }.reverse).should == cities.reverse }
+    specify { subject.load(deleted.map { |c| double(id: c.id) }).should == [nil, nil] }
+    specify { subject.load((cities + deleted).map { |c| double(id: c.id) }).should == [*cities, nil, nil] }
+    specify { subject.load(cities.map { |c| double(id: c.id) }, scope: ->(_) { where(country_id: 0) })
+      .should == cities.first(2) + [nil] }
+    specify { subject.load(cities.map { |c| double(id: c.id) }, scope: City.where(country_id: 1))
+      .should == [nil, nil] + cities.last(1) }
+  end
+end

data/spec/chewy/type/adapter/object_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Chewy::Type::Adapter::Object do
+  before { stub_class(:product) }
+
+  describe '#name' do
+    specify { described_class.new('product').name.should == 'Product' }
+    specify { described_class.new(:products).name.should == 'Products' }
+    specify { described_class.new(Product).name.should == 'Product' }
+    specify { described_class.new(Product, name: 'house').name.should == 'House' }
+  end
+
+  describe '#type_name' do
+    specify { described_class.new('product').type_name.should == 'product' }
+    specify { described_class.new(:products).type_name.should == 'products' }
+    specify { described_class.new(Product).type_name.should == 'product' }
+    specify { described_class.new(Product, name: 'house').type_name.should == 'house' }
+  end
+
+  describe '#import' do
+    def import(*args)
+      result = []
+      subject.import(*args) { |data| result.push data }
+      result
+    end
+
+    specify { subject.import(3.times.map { |i| double }) { |data| true }.should be_true }
+    specify { subject.import(3.times.map { |i| double }) { |data| false }.should be_false }
+
+    context do
+      let(:objects) { 3.times.map { |i| double } }
+      let(:deleted) { 2.times.map { |i| double(destroyed?: true) } }
+      subject { described_class.new('product') }
+
+      specify { import.should == [] }
+      specify { import(objects).should == [{index: objects}] }
+      specify { import(objects, batch_size: 2)
+          .should == [{index: objects.first(2)}, {index: objects.last(1)}] }
+      specify { import(objects, deleted).should == [{index: objects, delete: deleted}] }
+      specify { import(objects, deleted, batch_size: 2).should == [
+          {index: objects.first(2)},
+          {index: objects.last(1), delete: deleted.first(1)},
+          {delete: deleted.last(1)}] }
+    end
+
+    context do
+      let(:products) { 3.times.map { |i| double.tap { |product|
+        product.stub(:is_a?).with(Product).and_return(true)
+      } } }
+      let(:non_product) { double }
+      subject { described_class.new(Product) }
+
+      specify { import(products).should == [{index: products}] }
+      specify { expect { import(products, non_product) {} }.to raise_error }
+    end
+  end
+
+  describe '#load' do
+    context do
+      subject { described_class.new('product') }
+      let(:objects) { 3.times.map { |i| double } }
+
+      specify { subject.load(objects).should == objects }
+    end
+
+    context do
+      before { Product.stub(:wrap) { |object| object.stub(wrapped?: true); object } }
+      subject { described_class.new(Product) }
+      let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
+
+      specify { subject.load(objects).should satisfy { |objects| objects.all?(&:wrapped?) } }
+    end
+
+    context do
+      before { Product.stub(:wrap) { |object| nil } }
+      subject { described_class.new(Product) }
+      let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
+
+      specify { subject.load(objects).should satisfy { |objects| objects.all?(&:nil?) } }
+    end
+  end
+end