wvanbergen-scoped_search 1.2.0 → 2.0.0

data/spec/integration/relation_querying_spec.rb

@@ -0,0 +1,258 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch do
+
+  before(:all) do
+    ScopedSearch::Spec::Database.establish_connection
+  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

data/spec/integration/string_querying_spec.rb

@@ -0,0 +1,187 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch, :search_for do
+
+  before(:all) do
+    ScopedSearch::Spec::Database.establish_connection
+    @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

data/spec/lib/database.rb

@@ -0,0 +1,44 @@
+ActiveRecord::Migration.verbose = false unless ENV.has_key?('DEBUG')
+
+module ScopedSearch::Spec::Database
+
+  def self.establish_connection
+    if ENV['DATABASE']
+      self.establish_named_connection(ENV['DATABASE'])
+    else
+      self.establish_default_connection
+    end  
+  end
+
+  def self.establish_named_connection(name)
+    @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/../database.yml"))
+    raise "#{name} database not configured" if @database_connections[name.to_s].nil?
+    ActiveRecord::Base.establish_connection(@database_connections[name.to_s])
+  end
+
+  def self.establish_default_connection
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+  end
+
+  def self.close_connection
+    ActiveRecord::Base.remove_connection
+  end
+  
+  def self.create_model(fields)
+    table_name = "model_#{rand}".gsub(/\./, '')
+    ActiveRecord::Migration.create_table(table_name) do |t| 
+      fields.each do |name, field_type| 
+        t.send(field_type.to_s.gsub(/^unindexed_/, '').to_sym, name)
+      end
+    end
+    
+    klass = Class.new(ActiveRecord::Base)
+    klass.set_table_name(table_name)
+    yield(klass) if block_given?
+    return klass
+  end
+  
+  def self.drop_model(klass)
+    ActiveRecord::Migration.drop_table(klass.table_name)
+  end
+end