textacular 3.2.0 → 3.2.1

data/spec/textacular/searchable_spec.rb

@@ -1,102 +1,183 @@
-require 'spec_helper'
-require 'textacular/searchable'
+require 'support/web_comic_with_searchable'
+require 'support/web_comic_with_searchable_name'
+require 'support/web_comic_with_searchable_name_and_author'
+require 'support/character'
 
-class SearchableTest < Test::Unit::TestCase
+RSpec.describe "Searchable" do
   context "when extending an ActiveRecord::Base subclass" do
     context "with no parameters" do
-      setup do
-        @qcont = WebComicWithSearchable.create :name => "Questionable Content", :author => "Jeph Jaques"
-        @jhony = WebComicWithSearchable.create :name => "Johnny Wander", :author => "Ananth & Yuko"
-        @ddeeg = WebComicWithSearchable.create :name => "Dominic Deegan", :author => "Mookie"
-        @penny = WebComicWithSearchable.create :name => "Penny Arcade", :author => "Tycho & Gabe"
-        @null  = WebComicWithSearchable.create :author => 'Foo'
+      let!(:questionable_content) do
+        WebComicWithSearchable.create(
+          name: 'Questionable Content',
+          author: 'Jeph Jaques',
+        )
       end
 
-      teardown do
-        WebComicWithSearchable.delete_all
+      let!(:johnny_wander) do
+        WebComicWithSearchable.create(
+          name: 'Johnny Wander',
+          author: 'Ananth & Yuko',
+        )
       end
 
-      should "search across all columns" do
-        assert_equal [@penny], WebComicWithSearchable.advanced_search("Penny")
-        assert_equal [@ddeeg], WebComicWithSearchable.advanced_search("Dominic")
+      let!(:dominic_deegan) do
+        WebComicWithSearchable.create(
+          name: 'Dominic Deegan',
+          author: 'Mookie',
+        )
       end
 
-      should "still rank with NULL columns" do
+      let!(:penny_arcade) do
+        WebComicWithSearchable.create(
+          name: 'Penny Arcade',
+          author: 'Tycho & Gabe',
+        )
+      end
+
+      let!(:null) do
+        WebComicWithSearchable.create(
+          author: 'Foo',
+        )
+      end
+
+      it "searches across all columns" do
+        expect(
+          WebComicWithSearchable.advanced_search("Penny")
+        ).to eq([penny_arcade])
+        expect(
+          WebComicWithSearchable.advanced_search("Dominic")
+        ).to eq([dominic_deegan])
+      end
+
+      it "ranks results, egen with NULL columns" do
         comic = WebComicWithSearchable.basic_search('Foo').first
         rank = comic.attributes.find { |key, value| key.to_s =~ /\Arank\d+\z/ }.last
 
-        assert rank
+        expect(rank).to be_present
       end
     end
 
-    context "with one column as parameter" do
-      setup do
-        @qcont = WebComicWithSearchableName.create :name => "Questionable Content", :author => "Jeph Jaques"
-        @jhony = WebComicWithSearchableName.create :name => "Johnny Wander", :author => "Ananth & Yuko"
-        @ddeeg = WebComicWithSearchableName.create :name => "Dominic Deegan", :author => "Mookie"
-        @penny = WebComicWithSearchableName.create :name => "Penny Arcade", :author => "Tycho & Gabe"
+    context "with one column as a parameter" do
+      let!(:questionable_content) do
+        WebComicWithSearchableName.create(
+          name: 'Questionable Content',
+          author: 'Jeph Jaques',
+        )
       end
 
-      teardown do
-        WebComicWithSearchableName.delete_all
+      let!(:johnny_wander) do
+        WebComicWithSearchableName.create(
+          name: 'Johnny Wander',
+          author: 'Ananth & Yuko',
+        )
       end
 
-      should "only search across the given column" do
-        assert_equal [@penny], WebComicWithSearchableName.advanced_search("Penny")
-        assert_empty WebComicWithSearchableName.advanced_search("Tycho")
+      let!(:dominic_deegan) do
+        WebComicWithSearchableName.create(
+          name: 'Dominic Deegan',
+          author: 'Mookie',
+        )
+      end
+
+      let!(:penny_arcade) do
+        WebComicWithSearchableName.create(
+          name: 'Penny Arcade',
+          author: 'Tycho & Gabe',
+        )
+      end
+
+      it "only searches across the given column" do
+        expect(WebComicWithSearchableName.advanced_search("Penny")).to eq([penny_arcade])
+
+        expect(WebComicWithSearchableName.advanced_search("Tycho")).to be_empty
       end
 
-      ["hello \\", "tebow!" , "food &"].each do |search_term|
-        should "be fine with searching for crazy character #{search_term} with plain search" do
-          # Uses plainto_tsquery
-          assert_equal [], WebComicWithSearchableName.basic_search(search_term)
+      describe "basic search" do # Uses plainto_tsquery
+        ["hello \\", "tebow!" , "food &"].each do |search_term|
+          it "works with interesting term \"#{search_term}\"" do
+            expect(WebComicWithSearchableName.basic_search(search_term)).to be_empty
+          end
         end
+      end
 
-        should "be not fine with searching for crazy character #{search_term} with advanced search" do
-          # Uses to_tsquery
-          assert_raise(ActiveRecord::StatementInvalid) do
-            WebComicWithSearchableName.advanced_search(search_term).first
+      describe "advanced_search" do # Uses to_tsquery
+        ["hello \\", "tebow!" , "food &"].each do |search_term|
+          it "fails with interesting term \"#{search_term}\"" do
+            expect {
+              WebComicWithSearchableName.advanced_search(search_term).first
+            }.to raise_error(ActiveRecord::StatementInvalid)
           end
         end
       end
 
-      should "fuzzy search stuff" do
-        assert_equal [@qcont], WebComicWithSearchableName.fuzzy_search('Questio')
+      it "does fuzzy searching" do
+        expect(
+          WebComicWithSearchableName.fuzzy_search('Questio')
+        ).to eq([questionable_content])
       end
 
-      should "define :searchable_columns as private" do
-        assert_raise(NoMethodError) { WebComicWithSearchableName.searchable_columns }
+      it "defines :searchable_columns as private" do
+        expect { WebComicWithSearchableName.searchable_columns }.to raise_error(NoMethodError)
+
         begin
           WebComicWithSearchableName.searchable_columns
         rescue NoMethodError => error
-          assert_match /private method/, error.message
+          expect(error.message).to match(/private method/)
         end
       end
 
-      should "define #indexable_columns which returns a write-proof Enumerable" do
-        assert_equal(Enumerator, WebComicWithSearchableName.indexable_columns.class)
-        assert_raise(NoMethodError) { WebComicWithSearchableName.indexable_columns[0] = 'foo' }
+      it "defines #indexable_columns which returns a write-proof Enumerable" do
+        expect(WebComicWithSearchableName.indexable_columns).to be_an(Enumerator)
+
+        expect {
+          WebComicWithSearchableName.indexable_columns[0] = 'foo'
+        }.to raise_error(NoMethodError)
       end
     end
 
     context "with two columns as parameters" do
-      setup do
-        @qcont = WebComicWithSearchableNameAndAuthor.create :name => "Questionable Content", :author => "Jeph Jaques"
-        @jhony = WebComicWithSearchableNameAndAuthor.create :name => "Johnny Wander", :author => "Ananth & Yuko"
-        @ddeeg = WebComicWithSearchableNameAndAuthor.create :name => "Dominic Deegan", :author => "Mookie"
-        @penny = WebComicWithSearchableNameAndAuthor.create :name => "Penny Arcade", :author => "Tycho & Gabe"
+      let!(:questionable_content) do
+        WebComicWithSearchableNameAndAuthor.create(
+          name: 'Questionable Content',
+          author: 'Jeph Jaques',
+        )
+      end
+
+      let!(:johnny_wander) do
+        WebComicWithSearchableNameAndAuthor.create(
+          name: 'Johnny Wander',
+          author: 'Ananth & Yuko',
+        )
       end
 
-      teardown do
-        WebComicWithSearchableNameAndAuthor.delete_all
+      let!(:dominic_deegan) do
+        WebComicWithSearchableNameAndAuthor.create(
+          name: 'Dominic Deegan',
+          author: 'Mookie',
+        )
       end
 
-      should "only search across the given column" do
-        assert_equal [@penny], WebComicWithSearchableNameAndAuthor.advanced_search("Penny")
-        assert_equal [@penny], WebComicWithSearchableNameAndAuthor.advanced_search("Tycho")
+      let!(:penny_arcade) do
+        WebComicWithSearchableNameAndAuthor.create(
+          name: 'Penny Arcade',
+          author: 'Tycho & Gabe',
+        )
       end
-      should "allow includes" do
-        assert_equal [@penny], WebComicWithSearchableNameAndAuthor.includes(:characters).advanced_search("Penny")
+
+      it "only searches across the given columns" do
+        expect(
+          WebComicWithSearchableNameAndAuthor.advanced_search("Penny")
+        ).to eq([penny_arcade])
+
+        expect(
+          WebComicWithSearchableNameAndAuthor.advanced_search("Tycho")
+        ).to eq([penny_arcade])
+      end
+
+      it "allows includes" do
+        expect(
+          WebComicWithSearchableNameAndAuthor.includes(:characters).advanced_search("Penny")
+        ).to eq([penny_arcade])
       end
     end
   end

data/spec/textacular/trigram_installer_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe "Textacular::TrigramInstaller" do
+  let(:content) do
+    <<-MIGRATION
+class InstallTrigram < ActiveRecord::Migration
+  def self.up
+    ActiveRecord::Base.connection.execute("CREATE EXTENSION pg_trgm;")
+  end
+
+  def self.down
+    ActiveRecord::Base.connection.execute("DROP EXTENSION pg_trgm;")
+  end
+end
+MIGRATION
+  end
+
+  it "generates a migration" do
+    generator = double(:migration_generator)
+
+    expect(Textacular::MigrationGenerator).to receive(:new).with('install_trigram', content).and_return(generator)
+    expect(generator).to receive(:generate_migration)
+
+    Textacular::TrigramInstaller.new.generate_migration
+  end
+end

data/spec/textacular_spec.rb

@@ -1,215 +1,357 @@
 # coding: utf-8
-require 'spec_helper'
+# Above for Ruby 1.9 tests
 
-class TextacularTest < Test::Unit::TestCase
+require 'support/ar_stand_in'
+require 'support/not_there'
+require 'support/textacular_web_comic'
+require 'support/game_extended_with_textacular'
+require 'support/game_extended_with_textacular_and_custom_language'
+require 'support/game_fail_extended_with_textacular'
+
+RSpec.describe Textacular do
   context "after extending ActiveRecord::Base" do
-    should "not break #respond_to?" do
-      assert_nothing_raised do
-        ARStandIn.respond_to? :abstract_class?
-      end
+    it "doesn't break #respond_to?" do
+      expect{ ARStandIn.respond_to?(:abstract_class?) }.to_not raise_error
     end
 
-    should "not break #respond_to? for table-less classes" do
-      assert !NotThere.table_exists?
-      assert_nothing_raised do
-        NotThere.respond_to? :system
-      end
+    it "doesn't break #respond_to? for table-less classes" do
+      expect(NotThere.table_exists?).to be_falsey
+      expect { NotThere.respond_to? :system }.to_not raise_error
     end
 
-    should "not break #method_missing" do
-      assert_raise(NoMethodError) { ARStandIn.random }
+    it "doesn't break #method_missing" do
+      expect { ARStandIn.random }.to raise_error(NoMethodError)
+
       begin
         ARStandIn.random
       rescue NoMethodError => error
-        assert_match /undefined method `random'/, error.message
+        expect(error.message).to match(/undefined method `random'/)
       end
     end
 
-    should "not break #method_missing for table-less classes" do
-      assert !NotThere.table_exists?
-      assert_raise(NoMethodError) { NotThere.random }
+    it "doesn't break #method_missing for table-less classes" do
+      expect(NotThere.table_exists?).to be_falsey
+
+      expect { NotThere.random }.to raise_error(NoMethodError)
+
       begin
         NotThere.random
       rescue NoMethodError => error
-        assert_match /undefined method `random'/, error.message
+        expect(error.message).to match(/undefined method `random'/)
       end
     end
 
     context "when finding models based on searching a related model" do
-      setup do
-        @qc = TextacularWebComic.create :name => "Questionable Content", :author => "Jeph Jaques"
-        @jw = TextacularWebComic.create :name => "Johnny Wander", :author => "Ananth & Yuko"
-        @pa = TextacularWebComic.create :name => "Penny Arcade", :author => "Tycho & Gabe"
-
-        @gabe = @pa.characters.create :name => 'Gabe', :description => 'the simple one'
-        @tycho = @pa.characters.create :name => 'Tycho', :description => 'the wordy one'
-        @div = @pa.characters.create :name => 'Div', :description => 'a crude divx player with anger management issues'
-
-        @martin = @qc.characters.create :name => 'Martin', :description => 'the insecure protagonist'
-        @faye = @qc.characters.create :name => 'Faye', :description => 'a sarcastic barrista with anger management issues'
-        @pintsize = @qc.characters.create :name => 'Pintsize', :description => 'a crude AnthroPC'
-
-        @ananth = @jw.characters.create :name => 'Ananth', :description => 'Stubble! What is under that hat?!?'
-        @yuko = @jw.characters.create :name => 'Yuko', :description => 'So... small. Carl Sagan haircut.'
-        @john = @jw.characters.create :name => 'John', :description => 'Tall. Anger issues?'
-        @cricket = @jw.characters.create :name => 'Cricket', :description => 'Chirrup!'
+      let(:webcomics_with_tall_characters) do
+        [johnny_wander]
       end
 
-      teardown do
-        TextacularWebComic.delete_all
-        Character.delete_all
+      let(:webcomics_with_angry_characters) do
+        [johnny_wander, penny_arcade, questionable_content]
       end
 
-      should "look in the related model with nested searching syntax" do
-        assert_equal [@jw], TextacularWebComic.joins(:characters).advanced_search(:characters => {:description => 'tall'})
-        assert_equal [@pa, @jw, @qc].sort, TextacularWebComic.joins(:characters).advanced_search(:characters => {:description => 'anger'}).sort
-        assert_equal [@pa, @qc].sort, TextacularWebComic.joins(:characters).advanced_search(:characters => {:description => 'crude'}).sort
+      let(:webcomics_with_crude_characters) do
+        [penny_arcade, questionable_content]
       end
-    end
-  end
 
-  context "after extending an ActiveRecord::Base subclass" do
-    setup do
-      @zelda = GameExtendedWithTextacular.create :system => "NES",     :title => "Legend of Zelda",    :description => "A Link to the Past."
-      @mario = GameExtendedWithTextacular.create :system => "NES",     :title => "Super Mario Bros.",  :description => "The original platformer."
-      @sonic = GameExtendedWithTextacular.create :system => "Genesis", :title => "Sonic the Hedgehog", :description => "Spiky."
-      @dkong = GameExtendedWithTextacular.create :system => "SNES",    :title => "Diddy's Kong Quest", :description => "Donkey Kong Country 2"
-      @megam = GameExtendedWithTextacular.create :system => nil,       :title => "Mega Man",           :description => "Beware Dr. Brain"
-      @sfnes = GameExtendedWithTextacular.create :system => "SNES",    :title => "Street Fighter 2",   :description => "Yoga Flame!"
-      @sfgen = GameExtendedWithTextacular.create :system => "Genesis", :title => "Street Fighter 2",   :description => "Yoga Flame!"
-      @takun = GameExtendedWithTextacular.create :system => "Saturn",  :title => "Magical Tarurūto-kun", :description => "カッコイイ！"
-    end
-
-    teardown do
-      GameExtendedWithTextacular.delete_all
-    end
-
-    should "not break respond_to? when connection is unavailable" do
-      GameFailExtendedWithTextacular.establish_connection({:adapter => :postgresql, :database =>'unavailable', :username=>'bad', :pool=>5, :timeout=>5000}) rescue nil
-
-      assert_nothing_raised do
-        GameFailExtendedWithTextacular.respond_to?(:advanced_search)
-      end
-    end
-
-    should "define a #search method" do
-      assert GameExtendedWithTextacular.respond_to?(:search)
-    end
-
-    context "when searching with a String argument" do
-      should "search across all :string columns if no indexes have been specified" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search("Mario")
-        assert_equal Set.new([@mario, @zelda]), GameExtendedWithTextacular.advanced_search("NES").to_set
+      let!(:johnny_wander) do
+        TextacularWebComic.create(:name => "Johnny Wander", :author => "Ananth & Yuko").tap do |comic|
+          comic.characters.create :name => 'Ananth', :description => 'Stubble! What is under that hat?!?'
+          comic.characters.create :name => 'Yuko', :description => 'So... small. Carl Sagan haircut.'
+          comic.characters.create :name => 'John', :description => 'Tall. Anger issues?'
+          comic.characters.create :name => 'Cricket', :description => 'Chirrup!'
+        end
       end
 
-      should "work if the query contains an apostrophe" do
-        assert_equal [@dkong], GameExtendedWithTextacular.advanced_search("Diddy's")
+      let!(:questionable_content) do
+        TextacularWebComic.create(:name => "Questionable Content", :author => "Jeph Jaques").tap do |comic|
+          comic.characters.create :name => 'Martin', :description => 'the insecure protagonist'
+          comic.characters.create :name => 'Faye', :description => 'a sarcastic barrista with anger management issues'
+          comic.characters.create :name => 'Pintsize', :description => 'a crude AnthroPC'
+        end
       end
 
-      should "work if the query contains whitespace" do
-        assert_equal [@megam], GameExtendedWithTextacular.advanced_search("Mega Man")
+      let!(:penny_arcade) do
+        TextacularWebComic.create(:name => "Penny Arcade", :author => "Tycho & Gabe").tap do |comic|
+          comic.characters.create :name => 'Gabe', :description => 'the simple one'
+          comic.characters.create :name => 'Tycho', :description => 'the wordy one'
+          comic.characters.create :name => 'Div', :description => 'a crude divx player with anger management issues'
+        end
       end
 
-      should "work if the query contains an accent" do
-        assert_equal [@takun], GameExtendedWithTextacular.advanced_search("Tarurūto-kun")
+      it "looks in the related model with nested searching syntax" do
+        expect(
+          TextacularWebComic.joins(:characters).advanced_search(
+            :characters => {:description => 'tall'}
+          )
+        ).to eq(webcomics_with_tall_characters)
+
+        expect(
+          TextacularWebComic.joins(:characters).advanced_search(
+            :characters => {:description => 'anger'}
+          ).sort
+        ).to eq(webcomics_with_angry_characters.sort)
+
+        expect(
+          TextacularWebComic.joins(:characters).advanced_search(
+            :characters => {:description => 'crude'}
+          ).sort
+        ).to eq(webcomics_with_crude_characters.sort)
       end
+    end
+  end
 
-      should "search across records with NULL values" do
-        assert_equal [@megam], GameExtendedWithTextacular.advanced_search("Mega")
+  context "after extending an ActiveRecord::Base subclass" do
+    context "when the DB connection is unavailable" do
+      before do
+        GameFailExtendedWithTextacular.establish_connection({:adapter => :postgresql, :database =>'unavailable', :username=>'bad', :pool=>5, :timeout=>5000}) rescue nil
       end
 
-      should "scope consecutively" do
-        assert_equal [@sfgen], GameExtendedWithTextacular.advanced_search("Genesis").advanced_search("Street Fighter")
+      it "doesn't break respond_to?" do
+        expect { GameFailExtendedWithTextacular.respond_to?(:advanced_search) }.to_not raise_error
       end
     end
 
-    context "when searching with a Hash argument" do
-      should "search across the given columns" do
-        assert_empty GameExtendedWithTextacular.advanced_search(:title => "NES")
-        assert_empty GameExtendedWithTextacular.advanced_search(:system => "Mario")
-        assert_empty GameExtendedWithTextacular.advanced_search(:system => "NES", :title => "Sonic")
-
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search(:title => "Mario")
-
-        assert_equal 2, GameExtendedWithTextacular.advanced_search(:system => "NES").count
-
-        assert_equal [@zelda], GameExtendedWithTextacular.advanced_search(:system => "NES", :title => "Zelda")
-        assert_equal [@megam], GameExtendedWithTextacular.advanced_search(:title => "Mega")
+    context "when the DB connection is available" do
+      let!(:zelda) do
+        GameExtendedWithTextacular.create(
+          :system => "NES",
+          :title => "Legend of Zelda",
+          :description => "A Link to the Past."
+        )
       end
 
-      should "scope consecutively" do
-        assert_equal [@sfgen], GameExtendedWithTextacular.advanced_search(:system => "Genesis").advanced_search(:title => "Street Fighter")
+      let!(:mario) do
+        GameExtendedWithTextacular.create(
+          :system => "NES",
+          :title => "Super Mario Bros.",
+          :description => "The original platformer."
+        )
       end
 
-      should "cast non-:string columns as text" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search(:id => @mario.id)
-      end
-    end
-
-    context "when using dynamic search methods" do
-      should "generate methods for each :string column" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search_by_title("Mario")
-        assert_equal [@takun], GameExtendedWithTextacular.advanced_search_by_system("Saturn")
+      let!(:sonic) do
+        GameExtendedWithTextacular.create(
+          :system => "Genesis",
+          :title => "Sonic the Hedgehog",
+          :description => "Spiky."
+        )
       end
 
-      should "generate methods for each :text column" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search_by_description("platform")
+      let!(:donkey_kong) do
+        GameExtendedWithTextacular.create(
+          :system => "SNES",
+          :title => "Diddy's Kong Quest",
+          :description => "Donkey Kong Country 2"
+        )
       end
 
-      should "generate methods for any combination of :string and :text columns" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search_by_title_and_system("Mario", "NES")
-        assert_equal [@sonic], GameExtendedWithTextacular.advanced_search_by_system_and_title("Genesis", "Sonic")
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search_by_title_and_title("Mario", "Mario")
-        assert_equal [@megam], GameExtendedWithTextacular.advanced_search_by_title_and_description("Man", "Brain")
+      let!(:mega_man) do
+        GameExtendedWithTextacular.create(
+          :system => nil,
+          :title => "Mega Man",
+          :description => "Beware Dr. Brain"
+        )
       end
 
-      should "generate methods for inclusive searches" do
-        assert_equal Set.new([@megam, @takun]), GameExtendedWithTextacular.advanced_search_by_system_or_title("Saturn", "Mega Man").to_set
+      let!(:sf_nes) do
+        GameExtendedWithTextacular.create(
+          :system => "SNES",
+          :title => "Street Fighter 2",
+          :description => "Yoga Flame!"
+        )
       end
 
-      should "scope consecutively" do
-        assert_equal [@sfgen], GameExtendedWithTextacular.advanced_search_by_system("Genesis").advanced_search_by_title("Street Fighter")
+      let!(:sf_genesis) do
+        GameExtendedWithTextacular.create(
+          :system => "Genesis",
+          :title => "Street Fighter 2",
+          :description => "Yoga Flame!"
+        )
       end
 
-      should "generate methods for non-:string columns" do
-        assert_equal [@mario], GameExtendedWithTextacular.advanced_search_by_id(@mario.id)
+      let!(:takun) do
+        GameExtendedWithTextacular.create(
+          :system => "Saturn",
+          :title => "Magical Tarurūto-kun",
+          :description => "カッコイイ！"
+        )
       end
 
-      should "work with #respond_to?" do
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_system)
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_title)
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_system_and_title)
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_system_or_title)
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_title_and_title_and_title)
-        assert GameExtendedWithTextacular.respond_to?(:advanced_search_by_id)
-
-        assert !GameExtendedWithTextacular.respond_to?(:advanced_search_by_title_and_title_or_title)
+      it "defines a #search method" do
+        expect(GameExtendedWithTextacular).to respond_to(:search)
       end
 
-      should "allow for 2 arguments to #respond_to?" do
-        assert GameExtendedWithTextacular.respond_to?(:searchable_language, true)
-      end
-    end
+      describe "#advanced_search" do
+        context "with a String argument" do
+          it "searches across all :string columns (if not indexes have been specified)" do
+            expect(
+              GameExtendedWithTextacular.advanced_search("Mario")
+            ).to eq([mario])
+
+            expect(
+              GameExtendedWithTextacular.advanced_search("NES").to_set
+            ).to eq(Set.new([mario, zelda]))
+          end
+
+          it "works if a query has an apostrophe" do
+            expect(GameExtendedWithTextacular.advanced_search("Diddy's")).to eq([donkey_kong])
+          end
+
+          it "works if the query contains whitespace" do
+            expect(GameExtendedWithTextacular.advanced_search("Mega Man")).to eq([mega_man])
+          end
+
+          it "works if the query contains an accent" do
+            expect(GameExtendedWithTextacular.advanced_search("Tarurūto-kun")).to eq([takun])
+          end
+
+          it "searches across records with NULL values" do
+            expect(GameExtendedWithTextacular.advanced_search("Mega")).to eq([mega_man])
+          end
+
+          it "scopes consecutively" do
+            expect(
+              GameExtendedWithTextacular.advanced_search("Genesis").advanced_search("Street Fighter")
+            ).to eq([sf_genesis])
+          end
+        end
 
-    context "when searching after selecting columns to return" do
-      should "not fetch extra columns" do
-        assert_raise(ActiveModel::MissingAttributeError) do
-          GameExtendedWithTextacular.select(:title).advanced_search("Mario").first.system
+        context "with a Hash argument" do
+          it "searches across the given columns" do
+            expect(
+              GameExtendedWithTextacular.advanced_search(:title => 'NES')
+            ).to be_empty
+            expect(
+              GameExtendedWithTextacular.advanced_search(:system => "Mario")
+            ).to be_empty
+            expect(
+              GameExtendedWithTextacular.advanced_search(:system => "NES", :title => "Sonic")
+            ).to be_empty
+
+            expect(
+              GameExtendedWithTextacular.advanced_search(:title => "Mario")
+            ).to eq([mario])
+
+            expect(
+              GameExtendedWithTextacular.advanced_search(:system => "NES").size
+            ).to eq(2)
+
+            expect(
+              GameExtendedWithTextacular.advanced_search(:system => "NES", :title => "Zelda")
+            ).to eq([zelda])
+            expect(
+              GameExtendedWithTextacular.advanced_search(:title => "Mega")
+            ).to eq([mega_man])
+          end
+
+          it "scopes consecutively" do
+            expect(
+              GameExtendedWithTextacular
+                .advanced_search(:system => "Genesis")
+                .advanced_search(:title => "Street Fighter")
+            ).to eq([sf_genesis])
+          end
+
+          it "casts non-string columns as text" do
+            expect(
+              GameExtendedWithTextacular.advanced_search(:id => mario.id)
+            ).to eq([mario])
+          end
         end
-      end
-    end
 
-    context "when setting a custom search language" do
-      setup do
-        GameExtendedWithTextacularAndCustomLanguage.create :system => "PS3", :title => "Harry Potter & the Deathly Hallows"
-      end
+        context "via dynamic method names" do
+          it "only exists prior to 4.0.0" do
+            current_version = Gem::Version.new(Textacular.version)
+
+            expect(current_version).to be < Gem::Version.new("4.0.0")
+          end
+
+          it "generates methods for each string column" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_title("Mario")
+            ).to eq([mario])
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_system("Saturn")
+            ).to eq([takun])
+          end
+
+          it "generates methods for each text column" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_description("platform")
+            ).to eq([mario])
+          end
+
+          it "generates methods for any combination of string and text columns" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_title_and_system("Mario", "NES")
+            ).to eq([mario])
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_system_and_title("Genesis", "Sonic")
+            ).to eq([sonic])
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_title_and_title("Mario", "Mario")
+            ).to eq([mario])
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_title_and_description("Man", "Brain")
+            ).to eq([mega_man])
+          end
+
+          it "generates methods for inclusive searches" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_system_or_title("Saturn", "Mega Man").to_set
+            ).to eq(Set.new([mega_man, takun]))
+          end
+
+          it "scopes consecutively" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_system("Genesis").advanced_search_by_title("Street Fighter")
+            ).to eq([sf_genesis])
+          end
+
+          it "generates methods for non-string columns" do
+            expect(
+              GameExtendedWithTextacular.advanced_search_by_id(mario.id)
+            ).to eq([mario])
+          end
+
+          it "works with #respond_to?" do
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_system)
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_title)
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_system_and_title)
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_system_or_title)
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_title_and_title_and_title)
+            expect(GameExtendedWithTextacular).to respond_to(:advanced_search_by_id)
+
+            expect(GameExtendedWithTextacular).to_not respond_to(:advanced_search_by_title_and_title_or_title)
+          end
+
+          it "allows for 2 arguments to #respond_to?" do
+            expect(GameExtendedWithTextacular.respond_to?(:searchable_language, true)).to be_truthy
+          end
+        end
 
-      teardown do
-        GameExtendedWithTextacularAndCustomLanguage.delete_all
-      end
+        context "after selecting columns to return" do
+          it "doesn't fetch extra columns" do
+            expect {
+              GameExtendedWithTextacular.select(:title).advanced_search("Mario").first.system
+            }.to raise_error(ActiveModel::MissingAttributeError)
+          end
+        end
 
-      should "still find results" do
-        assert_not_empty GameExtendedWithTextacularAndCustomLanguage.advanced_search_by_title("harry")
+        context "after setting a custom language" do
+          let!(:harry_potter_7) do
+            GameExtendedWithTextacularAndCustomLanguage.create(
+              :system => "PS3",
+              :title => "Harry Potter & the Deathly Hallows"
+            )
+          end
+
+          it "finds results" do
+            expect(
+              GameExtendedWithTextacularAndCustomLanguage.advanced_search_by_title("harry")
+            ).to eq([harry_potter_7])
+          end
+        end
       end
     end
   end