mincer 0.1.2 → 0.2.0

data/spec/lib/{processors/cache_digest_spec.rb → mincer/processors/cache_digest/processor_spec.rb}

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
-describe ::Mincer::Processors::CacheDigest do
+describe ::Mincer::Processors::CacheDigest::Processor do
   context 'when postgres used' do
     before do
-      setup_basic_postgres_table
-      class ActiveRecordModel < ActiveRecord::Base
-      end
+      setup_postgres_table
       ActiveRecordModel.create!(text: 'Test1')
       ActiveRecordModel.create!(text: 'Test2')
     end
@@ -26,9 +24,4 @@ describe ::Mincer::Processors::CacheDigest do
     end
   end
 
-
-  context 'when postgres used' do
-
-  end
-
 end

data/spec/lib/{processors/paginate_spec.rb → mincer/processors/pagination/processor_spec.rb}

@@ -1,10 +1,8 @@
 require 'spec_helper'
 
-describe ::Mincer::Processors::Paginate do
+describe ::Mincer::Processors::Pagination::Processor do
   before do
     setup_basic_sqlite3_table
-    class ActiveRecordModel < ActiveRecord::Base
-    end
     30.times { |i| ActiveRecordModel.create(text: i) }
   end
 
@@ -39,10 +37,7 @@ describe ::Mincer::Processors::Paginate do
 
   context 'when WillPaginate is used for pagination' do
     before do
-      pending 'Need to fix test, need to unload Kaminari to test this'
-      #::Mincer::Processors::Paginator.any_instance.stub(:kaminari?).and_return(false)
-      #require 'will_paginate'
-      #require 'will_paginate/active_record'
+      ::Mincer::Processors::Pagination::Processor.stub(:kaminari?).and_return(false)
     end
 
     describe 'paginating with basic model without any Mincer::Base configuration' do
@@ -51,17 +46,11 @@ describe ::Mincer::Processors::Paginate do
       end
 
       it 'paginates by with provided page and per_page in args' do
-        query = subject.new(ActiveRecordModel, { 'page' => '2', 'per_page' => '20' })
-        query.to_a.count.should eq(10)
-      end
-
-      it 'paginates by default page(1) and per_page(10) when nothing passed to args' do
-        query = subject.new(ActiveRecordModel)
-        query.to_a.count.should eq(25)
+        ActiveRecord::Relation.any_instance.should_receive(:paginate).with(page: '2', per_page: '20')
+        subject.new(ActiveRecordModel, { 'page' => '2', 'per_page' => '20' })
       end
     end
 
-
     describe 'paginating when basic model has disabled pagination' do
       it 'returns all items' do
         subject = Class.new(Mincer::Base) do
@@ -76,8 +65,8 @@ describe ::Mincer::Processors::Paginate do
   context 'when there is no gem for pagination in loaded' do
     it 'returns all items' do
       subject = Class.new(Mincer::Base)
-      ::Mincer::Processors::Paginate.any_instance.stub(:kaminari?).and_return(false)
-      ::Mincer::Processors::Paginate.any_instance.stub(:will_paginate?).and_return(false)
+      ::Mincer::Processors::Pagination::Processor.stub(:kaminari?).and_return(false)
+      ::Mincer::Processors::Pagination::Processor.stub(:will_paginate?).and_return(false)
 
       query = subject.new(ActiveRecordModel)
       query.to_a.count.should eq(30)
@@ -85,4 +74,41 @@ describe ::Mincer::Processors::Paginate do
 
   end
 
+
+  describe 'configuration of pg_search' do
+    before do
+      Mincer.config.instance_variable_set('@pagination', nil)
+    end
+
+    describe 'param_name' do
+      it 'uses "page" as default value for page_param_name' do
+        Mincer.config.pagination.page_param_name.should == :page
+      end
+
+      it 'sets param_name string' do
+        Mincer.configure do |config|
+          config.pagination do |search|
+            search.page_param_name = 's'
+          end
+        end
+        Mincer.config.pagination.page_param_name.should == 's'
+      end
+    end
+
+    describe 'param_name' do
+      it 'uses :per_page as default value for per_page_param_name' do
+        Mincer.config.pagination.per_page_param_name.should == :per_page
+      end
+
+      it 'sets param_name string' do
+        Mincer.configure do |config|
+          config.pagination do |search|
+            search.per_page_param_name = 's'
+          end
+        end
+        Mincer.config.pagination.per_page_param_name.should == 's'
+      end
+    end
+  end
+
 end

data/spec/lib/{processors/pg_json_dumper_spec.rb → mincer/processors/pg_json_dumper/processor_spec.rb}

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
-describe ::Mincer::Processors::PgJsonDumper do
+describe ::Mincer::Processors::PgJsonDumper::Processor do
   context 'when postgres is used' do
     before do
-      setup_basic_postgres_table
-      class ActiveRecordModel < ActiveRecord::Base
-      end
+      setup_postgres_table
       ActiveRecordModel.create!(text: 'Test1')
       ActiveRecordModel.create!(text: 'Test2')
     end
@@ -48,8 +46,6 @@ describe ::Mincer::Processors::PgJsonDumper do
   context 'when postgres is NOT used' do
     before do
       setup_basic_sqlite3_table
-      class ActiveRecordModel < ActiveRecord::Base
-      end
       ActiveRecordModel.create!(id: 1, text: 'Test1')
       ActiveRecordModel.create!(id: 2, text: 'Test2')
     end

data/spec/lib/mincer/processors/pg_search/processor_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::PgSearch::Processor do
+  context 'when postgres used' do
+    before do
+      setup_postgres_table
+      ActiveRecordModel.create!(text: 'Test')
+      ActiveRecordModel.create!(text: 'Bingo')
+      ActiveRecordModel.create!(text: 'Bongo')
+    end
+
+    describe 'config' do
+      it 'defines method with pg_options' do
+        subject = Class.new(Mincer::Base) do
+          pg_search [{ columns: %w{"active_record_models"."tags" }, engines: [:array] }]
+        end
+        query = subject.new(ActiveRecordModel)
+        query.send(:pg_search_params).should == [{ columns: %w{"active_record_models"."tags" }, engines: [:array] }]
+      end
+    end
+
+    describe 'searching' do
+      describe 'searches with basic model without any Mincer::Base configuration' do
+        subject(:model) do
+          Class.new(Mincer::Base)
+        end
+
+        describe 'searching with fulltext search' do
+          it 'searches by pattern in args' do
+            query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+            query.to_a.count.should eq(1)
+          end
+
+          it 'avoids search when pattern is an empty string or spaces' do
+            query = subject.new(ActiveRecordModel, { 'pattern' => ' ' })
+
+            query.to_a.count.should eq(3)
+          end
+
+          context 'when another search_column exists with nil value on a found item' do
+            before do
+              setup_postgres_table([['id', 'SERIAL PRIMARY KEY'], ['text', 'TEXT'], ['text2', 'TEXT']])
+              ActiveRecordModel.create!(text: 'Test')
+              ActiveRecordModel.create!(text: 'Bingo')
+            end
+
+            it 'still includes found item in results' do
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+              query.to_a.count.should eq(1)
+            end
+          end
+
+          describe 'searching with 2 statements' do
+            before do
+              setup_postgres_table([['id', 'SERIAL PRIMARY KEY'], ['text', 'TEXT'], ['tags', 'TEXT[]']])
+              ActiveRecordModel.create!(text: 'Test', tags: ['a', 'b'])
+              ActiveRecordModel.create!(text: 'Bingo', tags: ['b', 'c'])
+            end
+
+            it 'searches using 2 statements' do
+              subject = Class.new(Mincer::Base) do
+                pg_search [
+                    { :columns => %w{"active_record_models"."tags" }, engines: [:array] },
+                    { :columns => %w{"active_record_models"."text" }, engines: [:fulltext] }
+                ]
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'c' })
+              query.to_a.count.should eq(1)
+              query.to_a.first.text.should == 'Bingo'
+
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'Test' })
+              query.to_a.count.should eq(1)
+              query.to_a.first.text.should == 'Test'
+            end
+
+            it 'searches using 2 statements with aggregator set to :and' do
+              subject = Class.new(Mincer::Base) do
+                pg_search [
+                    { :columns => %w{"active_record_models"."tags" }, engines: [:array] },
+                    { :columns => %w{"active_record_models"."text" }, engines: [:fulltext] }
+                ], join_with: :and
+              end
+
+              ActiveRecordModel.create!(text: 'O', tags: ['O'])
+
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'O' })
+              query.to_a.count.should eq(1)
+              query.to_a.first.text.should == 'O'
+            end
+          end
+
+
+          describe 'searching with array' do
+            before do
+              setup_postgres_table([['id', 'SERIAL PRIMARY KEY'], ['text', 'TEXT'], ['tags', 'TEXT[]']])
+              ActiveRecordModel.create!(text: 'Test', tags: ['a', 'b'])
+              ActiveRecordModel.create!(text: 'Bingo', tags: ['b', 'c'])
+            end
+
+            it 'includes 2 items when both items include pattern' do
+              subject = Class.new(Mincer::Base) do
+                pg_search [{ :columns => %w{"active_record_models"."tags" }, engines: [:array] }]
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'b' })
+              query.to_a.count.should eq(2)
+            end
+
+            it 'includes 1 item when match was found on one item' do
+              subject = Class.new(Mincer::Base) do
+                pg_search [{ :columns => %w{"active_record_models"."tags" }, engines: [:array] }]
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'c' })
+              query.to_a.count.should eq(1)
+            end
+
+            it 'includes both when matched with array overlap and option "any_word" set to true' do
+              subject = Class.new(Mincer::Base) do
+                pg_search [{ :columns => %w{"active_record_models"."tags" }, engines: [:array], any_word: true }]
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'a c d' })
+              query.to_a.count.should eq(2)
+            end
+
+            it 'includes both when matched with array overlap and option "any_word" set to true(separated with ",")' do
+              subject = Class.new(Mincer::Base) do
+                def pg_search_params
+                  [{ :columns => %w{"active_record_models"."tags"}, engines: [:array], any_word: true }]
+                end
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'a, c,d' })
+              query.to_a.count.should eq(2)
+            end
+
+            it 'includes no items when nothing matched pattern' do
+              subject = Class.new(Mincer::Base) do
+                def pg_search_params
+                  [{ :columns => %w{"active_record_models"."tags" }, engines: [:array] }]
+                end
+              end
+              query = subject.new(ActiveRecordModel, { 'pattern' => 'd e' })
+              query.to_a.count.should eq(0)
+            end
+
+          end
+        end
+      end
+
+
+      describe 'searching when basic model has disabled search' do
+        it 'does not modifies relation' do
+          subject = Class.new(Mincer::Base) do
+            skip_search!
+          end
+          query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+          query.to_a.count.should eq(3)
+        end
+      end
+    end
+  end
+
+  context 'when postgres is NOT used' do
+    before do
+      setup_basic_sqlite3_table
+      ActiveRecordModel.create!(text: 'Test')
+      ActiveRecordModel.create!(text: 'Bingo')
+      ActiveRecordModel.create!(text: 'Bongo')
+    end
+
+    subject(:model) do
+      Class.new(Mincer::Base)
+    end
+
+    it 'returns all records' do
+      query = subject.new(ActiveRecordModel, { 'pattern' => 'Bingo' })
+      query.to_a.count.should eq(3)
+    end
+  end
+
+
+  describe 'configuration of pg_search' do
+    before do
+      Mincer.config.instance_variable_set('@pg_search', nil)
+    end
+
+    describe 'param_name' do
+      it 'uses "pattern" as default value for param_name' do
+        Mincer.config.pg_search.param_name.should == 'pattern'
+      end
+
+      it 'sets param_name string' do
+        Mincer.configure do |config|
+          config.pg_search do |search|
+            search.param_name = 's'
+          end
+        end
+        Mincer.config.pg_search.param_name.should == 's'
+      end
+    end
+
+    describe 'fulltext_engine' do
+      it 'sets "ignore_accent" to true as default value' do
+        Mincer.config.pg_search.fulltext_engine[:ignore_accent].should be_true
+      end
+
+      it 'sets "any_word" to false as default value' do
+        Mincer.config.pg_search.fulltext_engine[:any_word].should be_false
+      end
+
+      it 'sets "dictionary" to "simple" as default value' do
+        Mincer.config.pg_search.fulltext_engine[:dictionary].should == :simple
+      end
+
+      it 'sets "ignore_case" to "false" as default value' do
+        Mincer.config.pg_search.fulltext_engine[:ignore_case].should be_false
+      end
+
+      it 'sets fulltext_engine options while merging with defaults' do
+        Mincer.configure do |config|
+          config.pg_search do |search|
+            search.fulltext_engine = search.fulltext_engine.merge(ignore_accent: false)
+          end
+        end
+        Mincer.config.pg_search.fulltext_engine.should == { ignore_accent: false, any_word: false, dictionary: :simple, ignore_case: false }
+      end
+    end
+
+    describe 'trigram_engine' do
+      it 'sets "ignore_accent" to true as default value' do
+        Mincer.config.pg_search.trigram_engine[:ignore_accent].should be_true
+      end
+
+      it 'sets "threshold" to 0.3 as default value' do
+        Mincer.config.pg_search.trigram_engine[:threshold].should == 0.3
+      end
+
+      it 'sets trigram_engine options while merging with defaults' do
+        Mincer.configure do |config|
+          config.pg_search do |search|
+            search.trigram_engine = search.trigram_engine.merge(threshold: 0.5)
+          end
+        end
+        Mincer.config.pg_search.trigram_engine.should == { ignore_accent: true, threshold: 0.5 }
+      end
+    end
+
+    describe 'array_engine' do
+      it 'sets "ignore_accent" to true as default value' do
+        Mincer.config.pg_search.array_engine[:ignore_accent].should be_true
+      end
+
+      it 'sets "any_word" to false as default value' do
+        Mincer.config.pg_search.array_engine[:any_word].should be_true
+      end
+
+      it 'sets array_engine options while merging with defaults' do
+        Mincer.configure do |config|
+          config.pg_search do |search|
+            search.array_engine = search.array_engine.merge(any_word: false)
+          end
+        end
+        Mincer.config.pg_search.array_engine.should == { ignore_accent: true, any_word: false }
+      end
+    end
+
+  end
+
+
+end

data/spec/lib/mincer/processors/pg_search/sanitizer_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe ::Mincer::Processors::PgSearch::Sanitizer do
+  before do
+    setup_postgres_table
+  end
+
+  describe '#sanitize' do
+    subject { ::Mincer::Processors::PgSearch::Sanitizer }
+    it 'applies "ignore_case" option' do
+      subject.sanitize_string('text', :ignore_case).to_sql.should == "lower('text')"
+    end
+
+    it 'applies "ignore_accent" option' do
+      subject.sanitize_string('text', :ignore_accent).to_sql.should == "unaccent('text')"
+    end
+
+    describe 'coalesce option' do
+      context 'when postgres extension installed' do
+        it 'applies "coalesce" option' do
+          subject.sanitize_string('text', :coalesce).to_sql.should == "coalesce('text', '')"
+        end
+      end
+      context 'when postgres extension is unavailable' do
+        it 'applies "coalesce" option' do
+          Mincer.instance_variable_get('@installed_extensions')[:unaccent] = false
+          subject.sanitize_string('text', :coalesce).to_sql.should == 'text'
+          Mincer.instance_variable_get('@installed_extensions')[:unaccent] = true
+        end
+      end
+    end
+
+    it 'applies multiple sanitizers' do
+      subject.sanitize_string('text', :ignore_case, :ignore_accent, :coalesce).to_sql.should == "unaccent(lower(coalesce('text', '')))"
+    end
+  end
+
+end

data/spec/lib/mincer/processors/pg_search/search_engines/array_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe ::Mincer::PgSearch::SearchEngines::Array do
+  before do
+    setup_postgres_table
+  end
+  subject(:search_engine_class) { ::Mincer::PgSearch::SearchEngines::Array }
+  let(:search_statement_class) { ::Mincer::Processors::PgSearch::SearchStatement }
+
+  describe '.search_engine_statements' do
+    context 'when 2 columns' do
+      it 'stores them in instance variable hash under :or key' do
+        search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:array])
+        search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:array])
+        search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+        search_engine.send(:search_engine_statements).should include(search_statement1)
+        search_engine.send(:search_engine_statements).should include(search_statement2)
+      end
+    end
+
+    it 'ignores other engines' do
+      search_statement1 = search_statement_class.new(['"records"."text"'])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:trigram])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+      search_engine.send(:search_engine_statements).should == []
+      search_engine.send(:search_engine_statements).should == []
+    end
+  end
+
+  describe '.conditions' do
+    it 'generates search condition with one column, one term and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:array])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[]) @> ARRAY['search']))}
+    end
+
+    it 'generates search condition with two columns, one term and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:array])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[] || "records"."text2"::text[]) @> ARRAY['search']))}
+    end
+
+    it 'generates search condition with two columns, two terms and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:array])
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[] || "records"."text2"::text[]) @> ARRAY['search','word']))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "ignore_accent" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:array], ignore_accent: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[] || "records"."text2"::text[]) @> ARRAY[unaccent('search'),unaccent('word')]))}
+    end
+
+    #TODO: sanitizer can not be set on array columns since we ned to unpack an reconstruct those arrays. Find a solution
+    it 'generates search condition with two columns, two terms and option "any_word" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:array], any_word: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[] || "records"."text2"::text[]) && ARRAY['search','word']))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "ignore_accent" and "ignore_case" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:array], ignore_accent: true, ignore_case: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[] || "records"."text2"::text[]) @> ARRAY[unaccent(lower('search')),unaccent(lower('word'))]))}
+    end
+
+    it 'generates search condition with one column, one term, two statements and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:array])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:array], any_word: true)
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[]) @> ARRAY['search']) OR (("records"."text2"::text[]) && ARRAY['search']))}
+    end
+
+    it 'generates search condition with one column, one term, two statements and no "param_name" options set to "s"' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:array])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:array], any_word: true, param_name: 's')
+      search_engine = search_engine_class.new({ pattern: 'search', s: 'word' }, [search_statement1, search_statement2])
+      search_engine.conditions.to_sql.should == %{((("records"."text"::text[]) @> ARRAY['search']) OR (("records"."text2"::text[]) && ARRAY['word']))}
+    end
+  end
+
+end

data/spec/lib/mincer/processors/pg_search/search_engines/fulltext_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe ::Mincer::PgSearch::SearchEngines::Fulltext do
+  before do
+    setup_postgres_table
+  end
+  subject(:search_engine_class) { ::Mincer::PgSearch::SearchEngines::Fulltext }
+  let(:search_statement_class) { ::Mincer::Processors::PgSearch::SearchStatement }
+
+  describe '.search_engine_statements' do
+    context 'when 2 columns' do
+      it 'stores them in instance variable hash under :or key' do
+        search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext])
+        search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:fulltext])
+        search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+        search_engine.send(:search_engine_statements).should include(search_statement1)
+        search_engine.send(:search_engine_statements).should include(search_statement2)
+      end
+    end
+
+    it 'ignores other engines' do
+      search_statement1 = search_statement_class.new(['"records"."text"'])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:array])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+      search_engine.send(:search_engine_statements).should == []
+      search_engine.send(:search_engine_statements).should == []
+    end
+  end
+
+  describe '.conditions' do
+    it 'generates search condition with one column, one term and no options with columns wrapped with coalesce' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", ''))) @@ (to_tsquery('simple', 'search'))))}
+    end
+
+    it 'generates search condition with two columns, one term and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", '')) || to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search'))))}
+    end
+
+    it 'generates search condition with two columns, two terms and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext])
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", '')) || to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search' || ' & ' || 'word'))))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "any_word" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext], any_word: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", '')) || to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search' || ' | ' || 'word'))))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "any_word" set to true while escaping special characters' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext], any_word: true)
+      search_engine = search_engine_class.new({ pattern: 'search word!(:&|) !' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", '')) || to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search' || ' | ' || 'word'))))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "ignore_accent" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext], ignore_accent: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', unaccent(coalesce("records"."text", ''))) || to_tsvector('simple', unaccent(coalesce("records"."text2", '')))) @@ (to_tsquery('simple', unaccent('search') || ' & ' || unaccent('word')))))}
+    end
+
+    it 'generates search condition with two columns, two terms and option "ignore_accent" and "ignore_case" set to true ' do
+      search_statement1 = search_statement_class.new(['"records"."text"', '"records"."text2"'], engines: [:fulltext], ignore_accent: true, ignore_case: true)
+      search_engine = search_engine_class.new({ pattern: 'search word' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', unaccent(lower(coalesce("records"."text", '')))) || to_tsvector('simple', unaccent(lower(coalesce("records"."text2", ''))))) @@ (to_tsquery('simple', unaccent(lower('search')) || ' & ' || unaccent(lower('word'))))))}
+    end
+
+    it 'generates search condition with one column, one term and option "dictionary" set to :english' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext], dictionary: :english)
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('english', coalesce("records"."text", ''))) @@ (to_tsquery('english', 'search'))))}
+    end
+
+    it 'generates search condition with two search statements one column, one term and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:fulltext])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", ''))) @@ (to_tsquery('simple', 'search'))) OR ((to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search'))))}
+    end
+
+    it 'generates search condition with one column, one term, two statements and no options' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:fulltext])
+      search_engine = search_engine_class.new({ pattern: 'search' }, [search_statement1, search_statement2])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", ''))) @@ (to_tsquery('simple', 'search'))) OR ((to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'search'))))}
+    end
+
+    it 'generates search condition with one column, one term, two statements and "param_name" option set to "s"' do
+      search_statement1 = search_statement_class.new(['"records"."text"'], engines: [:fulltext])
+      search_statement2 = search_statement_class.new(['"records"."text2"'], engines: [:fulltext], param_name: 's')
+      search_engine = search_engine_class.new({ pattern: 'search', s: 'word' }, [search_statement1, search_statement2])
+      search_engine.conditions.to_sql.should == %{(((to_tsvector('simple', coalesce("records"."text", ''))) @@ (to_tsquery('simple', 'search'))) OR ((to_tsvector('simple', coalesce("records"."text2", ''))) @@ (to_tsquery('simple', 'word'))))}
+    end
+  end
+
+end