clevic 0.8.0 → 0.11.1

data/test/test_helper.rb

@@ -0,0 +1,131 @@
+require 'test/unit'
+require 'shoulda'
+
+require File.dirname(__FILE__) + '/../lib/clevic'
+
+require 'activerecord'
+require 'sqlite3'
+require 'faker'
+require 'generator'
+
+
+class Flight < ActiveRecord::Base
+  has_many :passengers
+end
+
+class Passenger < ActiveRecord::Base
+  belongs_to :flight
+end
+
+class CreateFlights < ActiveRecord::Migration
+  def self.up
+    create_table :flights do |t|
+      t.string :number
+      t.string :airline
+      t.string :destination
+    end
+    Flight.reset_column_information
+    Flight.create :number => 'EK211'
+    Flight.create :number => 'EK088'
+    Flight.create :number => 'EK761'
+    Flight.create :number => 'BA264'
+  end
+  
+  def self.down
+    Flight.delete_all
+  end
+end
+
+class CreatePassengers < ActiveRecord::Migration
+  def self.up
+    create_table :passengers do |t|
+      t.string :name
+      t.string :nationality
+      t.integer :flight_id
+      t.integer :row
+      t.string :seat
+    end
+    Passenger.reset_column_information
+  end
+  
+  def self.down
+    Passenger.delete_all
+  end
+end
+
+# Convenience class to create a test DB
+class OneBase
+  attr_reader :db_name, :adapter
+  
+  def initialize
+    @db_name = 'test_cache_table.sqlite3'
+
+    if File.exists? @db_name
+      p 'remove old db'
+      File.unlink @db_name
+    end
+    
+    @adapter = :sqlite3
+    @db = SQLite3::Database.new( @db_name )
+    @db_options = Clevic::DbOptions.connect do |dbo|
+      dbo.database @db_name
+      dbo.adapter @adapter
+    end
+  end
+
+  def feenesh
+    File.unlink @db_name
+  end
+end
+
+# Allow running of startup and shutdown things before
+# an entire suite, instead of just one per test
+class SuiteWrapper < Test::Unit::TestSuite
+  attr_accessor :tests
+  
+  def initialize( name, test_case )
+    super( name )
+    @test_case = test_case
+  end
+  
+  def startup
+    @onebase = OneBase.new
+    ActiveRecord::Migration.verbose = false
+    CreateFlights.up
+    CreatePassengers.up
+  end
+  
+  def shutdown
+    CreatePassengers.down
+    CreateFlights.down
+    @onebase.feenesh
+  end
+  
+  def run( *args )
+    startup
+    @test_case.startup if @test_case.respond_to? :startup
+    retval = super
+    @test_case.shutdown if @test_case.respond_to? :shutdown
+    shutdown
+    retval
+  end
+end
+
+module Test
+  module Unit
+    class TestCase
+      unless respond_to? :old_suite
+        class << self
+          alias_method :old_suite, :suite
+        end
+        
+        def self.suite
+          os = old_suite
+          sw = SuiteWrapper.new( os.name, self )
+          sw.tests = os.tests
+          sw
+        end
+      end
+    end
+  end
+end

data/test/test_model_index_extensions.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestModelIndex < Test::Unit::TestCase
+  def self.startup
+  end
+  
+  def self.shutdown
+  end
+  
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  should_eventually 'test something'
+  
+  should 'be true' do
+    assert true
+  end
+  
+end

data/test/test_order_attribute.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'clevic/order_attribute.rb'
+
+class Dummy < ActiveRecord::Base
+end
+
+# need to set up a test DB, and test data for this
+class TestOrderAttribute < Test::Unit::TestCase
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def test_reverse
+    oa = OrderAttribute.new Dummy, 'id'
+    assert_equal :asc, oa.reverse( :desc )
+    assert_equal :desc, oa.reverse( :asc )
+    assert_raise( RuntimeError ) { oa.reverse( :something_wrong ) }
+  end
+  
+  # Test that initialisation was OK
+  def test_equal
+    oa1 = OrderAttribute.new Dummy, 'id'
+    oa2 = OrderAttribute.new Dummy, 'id'
+    assert_equal oa1, oa2
+    assert_equal oa1.to_sql, 'dummies.id asc'
+    assert_equal oa1.to_reverse_sql, 'dummies.id desc'
+    assert_equal oa1.attribute.to_sym, oa1.to_sym
+    
+    assert_equal oa2.to_sql, 'dummies.id asc'
+    assert_equal oa2.to_reverse_sql, 'dummies.id desc'
+  end
+  
+  def test_parse_default
+    oa_asc = OrderAttribute.new Dummy, "name"
+    assert_equal 'name', oa_asc.attribute
+    assert_equal :asc, oa_asc.direction
+  end
+  
+  def test_parse_desc
+    oa_desc = OrderAttribute.new Dummy, "name desc"
+    assert_equal 'name', oa_desc.attribute
+    assert_equal 'name', oa_desc.to_s
+    assert_equal :desc, oa_desc.direction
+    assert_equal oa_desc.to_sql, 'dummies.name desc'
+    assert_equal 'dummies.name asc', oa_desc.to_reverse_sql
+    
+    oa_desc = OrderAttribute.new Dummy, "dummies.name desc"
+    assert_equal 'name', oa_desc.attribute
+    assert_equal :desc, oa_desc.direction
+    assert_equal oa_desc.to_sql, 'dummies.name desc'
+  end
+  
+  def test_parse_table
+    oa_with_table = OrderAttribute.new Dummy, 'dummies.name asc'
+    assert_equal 'name', oa_with_table.attribute
+    assert_equal :asc, oa_with_table.direction
+    assert_equal oa_with_table.to_sql, 'dummies.name asc'
+  end
+  
+end

data/test/test_sql_dialects.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'clevic/sql_dialects.rb'
+
+# TODO should probably connect to real DB drivers to do this
+
+class MockPostgreSQL
+  include Clevic::SqlDialects
+  def adapter_name
+    'PostgreSQL'
+  end
+  
+  def connection
+    self
+  end
+  
+end
+
+class MockOther
+  include Clevic::SqlDialects
+  def adapter_name
+    'Something else entirely'
+  end
+  
+  def connection
+    self
+  end
+  
+  def quoted_true; "'t'"; end
+  def quoted_false; "'f'"; end
+end
+
+class TestSqlDialects < Test::Unit::TestCase
+  def self.startup
+  end
+  
+  def self.shutdown
+  end
+  
+  def setup
+  end
+  
+  context MockPostgreSQL.name do
+    setup do
+      @dialect = MockPostgreSQL.new
+    end
+    
+    should 'return ilike' do
+      assert_equal 'ilike', @dialect.like_operator
+    end
+    
+    should "return true" do
+      assert_equal "true", @dialect.sql_boolean( true )
+    end
+    
+    should "return false" do
+      assert_equal "false", @dialect.sql_boolean( false )
+    end
+  end
+  
+  context MockOther.name do
+    setup do
+      @dialect = MockOther.new
+    end
+    
+    should 'return like' do
+      assert_equal 'like', @dialect.like_operator
+    end
+    
+    should "return 't'" do
+      assert_equal "'t'", @dialect.sql_boolean( true )
+    end
+    
+    should "return 'f'" do
+      assert_equal "'f'", @dialect.sql_boolean( false )
+    end
+  end
+end

data/test/test_table_searcher.rb

@@ -0,0 +1,188 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'clevic/table_searcher.rb'
+
+class CreateFakePassengers < ActiveRecord::Migration
+  MAX_PASSENGERS = 100
+  NATIONALITIES = %w{Canada USA Britain UAE}
+  
+  def self.up
+    1.upto( MAX_PASSENGERS ) do |i|
+      Passenger.create :name => Faker::Name.name, :flight => Flight.find(:all)[i%4], :nationality => NATIONALITIES[i%4], :row => i, :seat => %w{A B C D}[i % 4]
+    end
+  end
+  
+  def self.down
+    Passenger.delete_all
+  end
+end
+
+class MockSearchCriteria
+
+  def initialize( &block )
+    @direction = :forwards
+    @from_start = false
+    @whole_words = false
+    self.instance_eval( &block ) if block_given?
+  end
+  
+  attr_accessor :direction, :search_text
+  attr_writer :whole_words, :from_start
+  def whole_words?; @whole_words; end
+  def from_start?; @from_start; end
+end
+
+class TestTableSearcher < Test::Unit::TestCase
+  def self.startup
+    CreateFakePassengers.up
+  end
+  
+  def self.shutdown
+    CreateFakePassengers.down
+  end
+  
+  def setup
+    @simple_search_criteria = MockSearchCriteria.new
+    @id_order_attribute = OrderAttribute.new( Passenger, 'id' )
+
+    @name_field = Clevic::Field.new( :name, Passenger, {} )
+    @nationality_field = Clevic::Field.new( :nationality, Passenger, {} )
+    @all_passengers = Passenger.find( :all, :conditions => [ 'flight_id = ?', Flight.find(:first).id ], :order => :id )
+  end
+
+  context 'on initialisation' do
+    should "have a matching field attribute on construction" do
+      ts = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @name_field )
+      assert_equal @name_field.attribute, ts.field.attribute
+    end
+
+    should "throw an exception when called with no order attributes" do
+      assert_raise( RuntimeError ) do
+        Clevic::TableSearcher.new( Passenger, nil, @simple_search_criteria, @name_field )
+      end
+    end
+
+    should "throw an exception when called with an empty collection of order attributes" do
+      assert_raise( RuntimeError ) do
+        Clevic::TableSearcher.new( Passenger, [], @simple_search_criteria, @name_field )
+      end
+    end
+      
+    should "throw an exception when called with no field" do
+      assert_raise( RuntimeError ) do
+        Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, nil )
+      end
+    end
+  
+    should 'throw an exception for an unknown direction' do
+      @simple_search_criteria.direction = :other
+      assert_raise( RuntimeError ) do
+        table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      end
+    end
+  end
+  
+  context "searching" do
+    setup do
+      @simple_search_criteria.search_text = CreateFakePassengers::NATIONALITIES[0]
+      @passenger_generator = Generator.new( @all_passengers )
+    end
+    
+    should "have #{CreateFakePassengers::MAX_PASSENGERS} passengers" do
+      assert_equal CreateFakePassengers::MAX_PASSENGERS, Passenger.count
+    end
+
+    should_eventually "do more granular testing"
+    
+    should "find the first record" do
+      @simple_search_criteria.from_start = true
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      assert_equal @all_passengers.first, table_searcher.search
+    end
+    
+    should "backwards-find the last record" do
+      @simple_search_criteria.from_start = true
+      @simple_search_criteria.direction = :backwards
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      assert_equal @all_passengers.last, table_searcher.search
+    end
+    
+    should "backwards-find the next-to-last record" do
+      # find the last record
+      @simple_search_criteria.from_start = true
+      @simple_search_criteria.direction = :backwards
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      last = table_searcher.search
+      
+      # now find the previous record
+      @simple_search_criteria.from_start = false
+      assert_equal @all_passengers[-2], table_searcher.search( last )
+    end
+
+    should "find next records" do
+      @simple_search_criteria.from_start = false
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      
+      # fetch records one by one, starting from the one after the first one, and compare them
+      while next_entity = table_searcher.search( @passenger_generator.next )
+        passenger = @passenger_generator.next
+        
+        assert_equal next_entity, passenger
+        assert_not_equal @all_passengers.first, passenger
+        
+        last_entity = next_entity
+      end
+    end
+  end
+  
+  context 'search for related field value' do
+    should 'raise an exception for no display value' do
+      @simple_search_criteria.from_start = true
+      @simple_search_criteria.search_text = Flight.find(:first).number
+      flight_field = Clevic::Field.new( :flight, Passenger, {} )
+      assert_nil flight_field.path
+      assert_raise RuntimeError do
+        table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, flight_field )
+        table_searcher.search
+      end
+    end
+
+    should 'find a record' do
+      @simple_search_criteria.from_start = true
+      @simple_search_criteria.search_text = Flight.find(:first).number
+      flight_field = Clevic::Field.new( :flight, Passenger, { :display => 'number' } )
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, flight_field )
+      assert_equal @all_passengers.first, table_searcher.search
+    end
+  end
+  
+  context 'whole words' do
+    setup do
+      @simple_search_criteria.from_start = true
+      @simple_search_criteria.search_text = CreateFakePassengers::NATIONALITIES[0][0..-3]
+      @should_find = Passenger.find :all, :conditions => "nationality like '%#{@simple_search_criteria.search_text}%'", :order => :id
+    end
+    
+    should 'find a full value with a partial search string' do
+      @simple_search_criteria.whole_words = false
+      @simple_search_criteria.from_start = true
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      g = Generator.new @should_find
+      last_entity = nil
+      while next_entity = table_searcher.search( last_entity )
+        assert_equal next_entity, g.next
+        last_entity = next_entity
+        @simple_search_criteria.from_start = false
+      end
+    end
+
+    should 'not find any values with a partial search string and whole_words enabled' do
+      @simple_search_criteria.whole_words = true
+      @simple_search_criteria.from_start = true
+      table_searcher = Clevic::TableSearcher.new( Passenger, [@id_order_attribute], @simple_search_criteria, @nationality_field )
+      assert_nil table_searcher.search
+    end
+  end
+  
+  should_eventually 'work for Array'
+
+end