scoped_search 2.0.1

data/spec/integration/ordinal_querying_spec.rb

@@ -0,0 +1,158 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::Spec::Database.test_databases.each do |db|
+  
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::Spec::Database.establish_named_connection(db)
+
+      @class = ScopedSearch::Spec::Database.create_model(:int => :integer, :timestamp => :datetime, :date => :date, :unindexed => :integer) do |klass|
+        klass.scoped_search :on => [:int, :timestamp]
+        klass.scoped_search :on => :date, :only_explicit => true
+      end
+    end
+
+    after(:all) do
+      ScopedSearch::Spec::Database.drop_model(@class)
+      ScopedSearch::Spec::Database.close_connection
+    end
+
+    context 'quering numerical fields' do
+
+      before(:all) do
+        @record = @class.create!(:int =>  9)
+      end
+
+      after(:all) do
+        @record.destroy
+      end
+
+      it "should find the record with an exact integer match" do
+        @class.search_for('9').should have(1).item
+      end
+
+      it "should find the record with an exact integer match with an explicit operator" do
+        @class.search_for('= 9').should have(1).item
+      end
+
+      it "should find the record with an exact integer match with an explicit field name" do
+        @class.search_for('int = 9').should have(1).item
+      end
+
+      it "should find the record with an exact integer match with an explicit field name" do
+        @class.search_for('int > 8').should have(1).item
+      end
+
+      it "should find the record with a grater than operator and explicit field" do
+        @class.search_for('int > 9').should have(0).item
+      end
+
+      it "should find the record with an >= operator with an implicit field name" do
+        @class.search_for('>= 9').should have(1).item
+      end
+
+      it "should not return the record if only one predicate is true and AND is used (by default)" do
+        @class.search_for('int <= 8, int > 8').should have(0).item
+      end
+
+      it "should return the record in only one predicate is true and OR is used as operator" do
+        @class.search_for('int <= 8 || int > 8').should have(1).item
+      end
+    end
+
+    context 'querying unindexed fields' do
+
+      before(:all) do
+        @record = @class.create!(:int =>  9, :unindexed => 10)
+      end
+
+      after(:all) do
+        @record.destroy
+      end
+
+      it "should raise an error when explicitly searching in the non-indexed column" do
+        lambda { @class.search_for('unindexed = 10') }.should raise_error(ScopedSearch::Exception)
+      end
+
+      it "should not return records for which the query matches unindex records" do
+        @class.search_for('= 10').should have(0).item
+      end
+    end
+
+    context 'querying date and time fields' do
+
+      before(:all) do
+        @record = @class.create!(:timestamp => Time.parse('2009-01-02 14:51:44'), :date => Date.parse('2009-01-02'))
+        @nil_record = @class.create!(:timestamp => nil, :date => nil)
+      end
+
+      after(:all) do
+        @record.destroy
+        @nil_record.destroy
+      end
+
+      it "should accept YYYY-MM-DD as date format" do
+        @class.search_for('date = 2009-01-02').should have(1).item
+      end
+
+      it "should accept YY-MM-DD as date format" do
+        @class.search_for('date = 09-01-02').should have(1).item
+      end
+
+      it "should accept MM/DD/YY as date format" do
+        @class.search_for('date = 01/02/09').should have(1).item
+      end
+
+      it "should accept YYYY/MM/DD as date format" do
+        @class.search_for('date = 2009/01/02').should have(1).item
+      end
+
+      it "should accept MM/DD/YYYY as date format" do
+        @class.search_for('date = 01/02/2009').should have(1).item
+      end
+
+      it "should ignore an invalid date and thus return all records" do
+        @class.search_for('>= 2009-14-57').should have(2).items
+      end
+
+      it "should find the records with a timestamp set some point on the provided date" do
+        @class.search_for('>= 2009-01-02').should have(1).item
+      end
+
+      it "should support full timestamps" do
+        @class.search_for('> "2009-01-02 02:02:02"').should have(1).item
+      end
+
+      it "should find no record with a timestamp in the past" do
+        @class.search_for('< 2009-01-02').should have(0).item
+      end
+
+      it "should find all timestamps on a date if no time is given using the = operator" do
+        @class.search_for('= 2009-01-02').should have(1).item
+      end
+
+      it "should find all timestamps on a date if no time is when no operator is given" do
+        @class.search_for('2009-01-02').should have(1).item
+      end
+
+      it "should find all timestamps not on a date if no time is given using the != operator" do
+        @class.search_for('!= 2009-01-02').should have(0).item
+      end
+
+      it "should find the records when the date part of a timestamp matches a date" do
+        @class.search_for('>= 2009-01-02').should have(1).item
+      end
+
+      it "should find the record with the timestamp today or in the past" do
+        @class.search_for('<= 2009-01-02').should have(1).item
+      end
+
+      it "should find no record with a timestamp later than today" do
+        @class.search_for('> 2009-01-02').should have(0).item
+      end
+    end
+  end
+end

data/spec/integration/relation_querying_spec.rb

@@ -0,0 +1,262 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::Spec::Database.test_databases.each do |db|
+
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::Spec::Database.establish_named_connection(db)
+    end
+
+    after(:all) do
+      ScopedSearch::Spec::Database.close_connection
+    end
+
+    context 'querying a :belongs_to relation' do
+
+      before(:all) do
+
+        # The related class
+        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
+        class Bar < ActiveRecord::Base; has_many :foos; end
+
+        # The class on which to call search_for
+        Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass|
+          klass.belongs_to :bar
+          klass.scoped_search :in => :bar, :on => :related
+        end
+
+        @bar_record = Bar.create!(:related => 'bar')
+
+        Foo.create!(:foo => 'foo',       :bar => @bar_record)
+        Foo.create!(:foo => 'foo too',   :bar => @bar_record)
+        Foo.create!(:foo => 'foo three', :bar => Bar.create!(:related => 'another bar'))
+        Foo.create!(:foo => 'foo four')
+      end
+
+      after(:all) do
+        ScopedSearch::Spec::Database.drop_model(Bar)
+        ScopedSearch::Spec::Database.drop_model(Foo)
+        Object.send :remove_const, :Foo
+        Object.send :remove_const, :Bar
+      end
+
+      it "should find all records with a related bar record containing bar" do
+        Foo.search_for('bar').should have(3).items
+      end
+
+      it "should find all records with a related bar record having an exact value of bar" do
+        Foo.search_for('= bar').should have(2).items
+      end
+
+      it "should find all records with a related bar record having an exact value of bar with an explicit field" do
+         Foo.search_for('related = bar').should have(2).items
+       end
+
+      it "should find records for which the bar relation is not set using null?" do
+        Foo.search_for('null? related').should have(1).items
+      end
+    end
+
+    context 'querying a :has_many relation' do
+
+      before(:all) do
+
+        # The related class
+        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
+        class Bar < ActiveRecord::Base; belongs_to :foo; end
+
+        # The class on which to call search_for
+        Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass|
+          klass.has_many :bars
+          klass.scoped_search :in => :bars, :on => :related
+        end
+
+        @foo_1 = Foo.create!(:foo => 'foo')
+        @foo_2 = Foo.create!(:foo => 'foo too')
+        @foo_3 = Foo.create!(:foo => 'foo three')
+
+        Bar.create!(:related => 'bar',         :foo => @foo_1)
+        Bar.create!(:related => 'another bar', :foo => @foo_1)
+        Bar.create!(:related => 'other bar',   :foo => @foo_2)
+      end
+
+      after(:all) do
+        ScopedSearch::Spec::Database.drop_model(Bar)
+        ScopedSearch::Spec::Database.drop_model(Foo)
+        Object.send :remove_const, :Foo
+        Object.send :remove_const, :Bar
+      end
+
+      it "should find all records with at least one bar record containing 'bar'" do
+        Foo.search_for('bar').should have(2).items
+      end
+
+      it "should find the only record with at least one bar record having the exact value 'bar'" do
+        Foo.search_for('= bar').should have(1).item
+      end
+
+      it "should find all records for which at least one related bar record exists" do
+        Foo.search_for('set? related').should have(2).items
+      end
+
+      it "should find all records for which none related bar records exist" do
+        Foo.search_for('null? related').should have(1).items
+      end
+
+    end
+
+    context 'querying a :has_one relation' do
+
+      before(:all) do
+
+        # The related class
+        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
+        class Bar < ActiveRecord::Base; belongs_to :foo; end
+
+        # The class on which to call search_for
+        Foo = ScopedSearch::Spec::Database.create_model(:foo => :string) do |klass|
+          klass.has_one :bar
+          klass.scoped_search :in => :bar, :on => :related
+        end
+
+        @foo_1 = Foo.create!(:foo => 'foo')
+        @foo_2 = Foo.create!(:foo => 'foo too')
+        @foo_3 = Foo.create!(:foo => 'foo three')
+
+        Bar.create!(:related => 'bar',         :foo => @foo_1)
+        Bar.create!(:related => 'other bar',   :foo => @foo_2)
+      end
+
+      after(:all) do
+        ScopedSearch::Spec::Database.drop_model(Bar)
+        ScopedSearch::Spec::Database.drop_model(Foo)
+        Object.send :remove_const, :Foo
+        Object.send :remove_const, :Bar
+      end
+
+      it "should find all records with a bar record containing 'bar" do
+        Foo.search_for('bar').should have(2).items
+      end
+
+      it "should find the only record with the bar record has the exact value 'bar" do
+        Foo.search_for('= bar').should have(1).item
+      end
+
+      it "should find all records for which the related bar record exists" do
+        Foo.search_for('set? related').should have(2).items
+      end
+
+      it "should find all records for which the related bar record does not exist" do
+        Foo.search_for('null? related').should have(1).items
+      end
+    end
+
+    context 'querying a :has_and_belongs_to_many relation' do
+
+      before(:all) do
+
+        # Create some tables
+        ActiveRecord::Migration.create_table(:bars) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:bars_foos, :id => false) { |t| t.integer :foo_id; t.integer :bar_id }
+        ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo }
+
+        # The related class
+        class Bar < ActiveRecord::Base; end
+
+        # The class on which to call search_for
+        class Foo < ActiveRecord::Base
+          has_and_belongs_to_many :bars
+          scoped_search :in => :bars, :on => :related
+        end
+
+        @foo_1 = Foo.create!(:foo => 'foo')
+        @foo_2 = Foo.create!(:foo => 'foo too')
+        @foo_3 = Foo.create!(:foo => 'foo three')
+
+        @bar_1 = Bar.create!(:related => 'bar')
+        @bar_2 = Bar.create!(:related => 'other bar')
+        @bar_3 = Bar.create!(:related => 'last bar')
+
+        @foo_1.bars << @bar_1 << @bar_2
+        @foo_2.bars << @bar_2 << @bar_3
+      end
+
+      after(:all) do
+        ActiveRecord::Migration.drop_table(:bars_foos)
+        ActiveRecord::Migration.drop_table(:bars)
+        ActiveRecord::Migration.drop_table(:foos)
+        Object.send :remove_const, :Foo
+        Object.send :remove_const, :Bar
+      end
+
+      it "should find all records with at least one associated bar record containing 'bar'" do
+        Foo.search_for('bar').should have(2).items
+      end
+
+      it "should find record which is related to @bar_1" do
+        Foo.search_for('= bar').should have(1).items
+      end
+
+      it "should find the only record related to @bar_3" do
+        Foo.search_for('last').should have(1).items
+      end
+
+      it "should find all records that are related to @bar_2" do
+        Foo.search_for('other').should have(2).items
+      end
+    end
+
+    context 'querying a :has_many => :through relation' do
+
+      before(:all) do
+
+        # Create some tables
+        ActiveRecord::Migration.create_table(:bars) { |t| t.integer :foo_id; t.integer :baz_id }
+        ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo }
+
+        # The related classes
+        class Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end
+        class Baz < ActiveRecord::Base; has_many :bars; end
+
+        # The class on which to call search_for
+        class Foo < ActiveRecord::Base
+          has_many :bars
+          has_many :bazs, :through => :bars
+
+          scoped_search :in => :bazs, :on => :related
+        end
+
+        @foo_1 = Foo.create!(:foo => 'foo')
+        @foo_2 = Foo.create!(:foo => 'foo too')
+        @foo_3 = Foo.create!(:foo => 'foo three')
+
+        @baz_1 = Baz.create(:related => 'baz')
+        @baz_2 = Baz.create(:related => 'baz too!')
+
+        @bar_1 = Bar.create!(:foo => @foo_1, :baz => @baz_1)
+        @bar_2 = Bar.create!(:foo => @foo_1)
+        @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_1)
+        @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2)
+        @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2)
+        @bar_4 = Bar.create!(:foo => @foo_3)
+      end
+
+      after(:all) do
+        ActiveRecord::Migration.drop_table(:bazs)
+        ActiveRecord::Migration.drop_table(:bars)
+        ActiveRecord::Migration.drop_table(:foos)
+        Object.send :remove_const, :Foo
+        Object.send :remove_const, :Bar
+        Object.send :remove_const, :Baz
+      end
+
+      it "should find the two records that are related to a baz record" do
+        Foo.search_for('baz').should have(2).items
+      end
+    end
+  end
+end

data/spec/integration/string_querying_spec.rb

@@ -0,0 +1,192 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::Spec::Database.test_databases.each do |db|
+
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::Spec::Database.establish_named_connection(db)
+    
+      @class = ScopedSearch::Spec::Database.create_model(:string => :string, :another => :string, :explicit => :string) do |klass|
+        klass.scoped_search :on => :string
+        klass.scoped_search :on => :another,  :default_operator => :eq, :alias => :alias
+        klass.scoped_search :on => :explicit, :only_explicit => true
+      end
+
+      @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz')
+      @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz')
+      @class.create!(:string => 'baz', :another => 'temp 3', :explicit => nil)
+    end
+
+    after(:all) do
+      ScopedSearch::Spec::Database.drop_model(@class)
+      ScopedSearch::Spec::Database.close_connection
+    end
+
+    context 'in an implicit string field' do
+      it "should find the record with an exact string match" do
+        @class.search_for('foo').should have(1).item
+      end
+
+      it "should find the opther two records using NOT with an exact string match" do
+        @class.search_for('-foo').should have(2).item
+      end
+
+      it "should find the record with an exact string match and an explicit field operator" do
+        @class.search_for('string = foo').should have(1).item
+      end
+
+      it "should find the record with an exact string match and an explicit field operator" do
+        @class.search_for('another = foo').should have(0).items
+      end
+
+      it "should find the record with an partial string match" do
+        @class.search_for('fo').should have(1).item
+      end
+
+      it "should find the other two records using NOT with an partial string match" do
+        @class.search_for('-fo').should have(2).item
+      end
+
+      it "should not find the record with an explicit equals operator and a partial match" do
+        @class.search_for('= fo').should have(0).items
+      end
+
+      it "should find the record with an explicit LIKE operator and a partial match" do
+        @class.search_for('~ fo').should have(1).items
+      end
+
+      it "should find the all other record with an explicit NOT LIKE operator and a partial match" do
+        @class.search_for('string !~ fo').should have(@class.count - 1).items
+      end
+
+      it "should not find a record with a non-match" do
+        @class.search_for('nonsense').should have(0).items
+      end
+
+      it "should find two records if it partially matches them" do
+        @class.search_for('ba').should have(2).item
+      end
+
+      it "should find no records starting with an a" do
+        @class.search_for('a%').should have(0).item
+      end
+
+      it "should find one records ending with an oo" do
+        @class.search_for('%oo').should have(1).item
+      end
+
+      it "should find records without case sensitivity when using the LIKE operator" do
+        @class.search_for('string ~ FOO').should have(1).item
+      end
+
+      it "should not find records without case sensitivity when using the = operator" do
+        @class.search_for('string = FOO').should have(0).items
+      end
+
+      it "should find records without case sensitivity when using the != operator" do
+        @class.search_for('string != FOO').should have(3).items
+      end
+
+      it "should find records without case sensitivity when using the NOT LIKE operator" do
+        @class.search_for('string !~ FOO').should have(2).items
+      end
+
+      it "should find the record if one of the query words match using OR" do
+        @class.search_for('foo OR nonsense').should have(1).item
+      end
+
+      it "should find no records in one of the AND conditions isn't met" do
+        @class.search_for('foo AND nonsense').should have(0).item
+      end
+
+      it "should find two records every single OR conditions matches one single record" do
+        @class.search_for('foo OR baz').should have(2).item
+      end
+
+      it "should find two records every single AND conditions matches one single record" do
+        @class.search_for('foo AND baz').should have(0).item
+      end
+    end
+
+    context 'in a field with a different default operator' do
+      it "should find an exact match" do
+        @class.search_for('"temp 1"').should have(1).item
+      end
+
+      it "should find the orther records using NOT and an exact match" do
+        @class.search_for('-"temp 1"').should have(2).item
+      end
+
+      it "should find an explicit match" do
+        @class.search_for('another = "temp 1"').should have(1).item
+      end
+
+      it "should not find a partial match" do
+        @class.search_for('temp').should have(0).item
+      end
+
+      it "should find all records using a NOT with a partial match on all records" do
+        @class.search_for('-temp"').should have(3).item
+      end
+
+      it "should find a partial match when the like operator is given" do
+        @class.search_for('~ temp').should have(3).item
+      end
+
+      it "should find a partial match when the like operator and the field name is given" do
+        @class.search_for('another ~ temp').should have(3).item
+      end
+    end
+
+    context 'using an aliased field' do
+      it "should find an explicit match using its alias" do
+        @class.search_for('alias = "temp 1"').should have(1).item
+      end
+    end
+
+    context 'in an explicit string field' do
+
+      it "should not find the records if the explicit field is not given in the query" do
+        @class.search_for('= baz').should have(1).item
+      end
+
+      it "should find all records when searching on the explicit field" do
+        @class.search_for('explicit = baz').should have(2).items
+      end
+
+      it "should find no records if the value in the explicit field is not an exact match" do
+        @class.search_for('explicit = ba').should have(0).item
+      end
+
+      it "should find all records when searching on the explicit field" do
+        @class.search_for('explicit ~ ba').should have(2).items
+      end
+
+      it "should only find the record with string = foo and explicit = baz" do
+        @class.search_for('foo, explicit = baz').should have(1).item
+      end
+    end
+
+    context 'using null? and set? queries' do
+
+      it "should return all records if the string field is being checked with set?" do
+        @class.search_for('set? string').should have(3).items
+      end
+
+      it "should return no records if the string field is being checked with null?" do
+        @class.search_for('null? string').should have(0).items
+      end
+
+      it "should return all records with a value if the string field is being checked with set?" do
+        @class.search_for('set? explicit').should have(2).items
+      end
+
+      it "should return all records without a value if the string field is being checked with null?" do
+        @class.search_for('null? explicit').should have(1).items
+      end
+    end
+  end
+end