runestone 1.0

data/test/multi_index_test.rb

@@ -0,0 +1,177 @@
+require 'test_helper'
+
+class MultiIndexTest < ActiveSupport::TestCase
+  
+  test 'simple index' do
+    address = assert_difference 'Runestone::Model.count', 2 do
+      assert_sql(/setweight\(to_tsvector\('english', 'empire state building'\), 'A'\)/, /setweight\(to_tsvector\('russian', 'эмпайр-стейт-билдинг'\), 'A'\)/) do
+        Building.create(name_en: 'Empire State Building', name_ru: 'Эмпайр-Стейт-Билдинг')
+      end
+    end
+    
+    assert_equal([
+      [
+        'Building', address.id,
+        nil, 'english',
+        {"name" => "Empire State Building"},
+        "'build':3A 'empir':1A 'state':2A"
+      ],
+      [
+        'Building', address.id,
+        nil, 'russian',
+        {"name" => "Эмпайр-Стейт-Билдинг"},
+        "'билдинг':4A 'стейт':3A 'эмпайр':2A 'эмпайр-стейт-билдинг':1A"
+      ],
+    ], address.runestones.map { |rs|
+      [
+        rs.record_type, rs.record_id,
+        rs.name, rs.dictionary,
+        rs.data,
+        rs.vector
+      ]
+    })
+    
+    query = Runestone::Model.search('empire')
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'empire:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'empire:*')
+      ORDER BY rank0 DESC
+    SQL
+    
+    query = Runestone::Model.search('empire', dictionary: 'english')
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('english', 'empire:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('english', 'empire:*')
+      AND "runestones"."dictionary" = 'english'
+      ORDER BY rank0 DESC
+    SQL
+    
+    query = Runestone::Model.search('Эмпайр', dictionary: 'russian')
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('russian', 'эмпайр:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('russian', 'эмпайр:*')
+      AND "runestones"."dictionary" = 'russian'
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test 'empty index' do
+    address = assert_difference 'Runestone::Model.count', 1 do
+      Address.create(name: nil)
+    end
+
+    assert_equal([[
+      'Address', address.id,
+      {},
+      ""
+    ]], address.runestones.map { |rs|
+      [
+        rs.record_type,
+        rs.record_id,
+        rs.data,
+        rs.vector
+      ]
+    })
+  end
+
+  test 'complex index' do
+    property = assert_difference 'Runestone::Model.count', 3 do
+      Property.create(name: 'Property name', addresses: [
+        Address.create(name: 'Address 1'),
+        Address.create(name: 'Address 2')
+      ])
+    end
+
+    assert_equal([[
+      'Property', property.id,
+      {
+        "name"=>"Property name",
+        "addresses"=>[
+          { "id" => property.addresses.first.id, "name" => "Address 1" },
+          { "id" => property.addresses.last.id,  "name" => "Address 2" }
+        ]
+      },
+      "'1':4C '2':6C 'address':3C,5C 'name':2A 'property':1A"
+    ]], property.runestones.map { |rs|
+      [
+        rs.record_type,
+        rs.record_id,
+        rs.data,
+        rs.vector
+      ]
+    })
+  end
+
+  test 'index gets created on Model.create' do
+    address = assert_difference 'Runestone::Model.count', 1 do
+      Address.create(name: 'Address name')
+    end
+  end
+
+  test 'index gets updated on Model.create' do
+    address = Address.create(name: 'Address name')
+    assert_no_difference 'Runestone::Model.count' do
+      address.update!(name: 'Address name two')
+    end
+
+    assert_equal([[
+      'Address', address.id,
+      {"name" => "Address name two"},
+      "'address':1A 'name':2A 'two':3A"
+    ]], address.runestones.map { |rs|
+      [
+        rs.record_type,
+        rs.record_id,
+        rs.data,
+        rs.vector
+      ]
+    })
+  end
+
+  test 'index gets deleted on Model.destroy' do
+    address = Address.create(name: 'Address name')
+    assert_difference 'Runestone::Model.count', -1 do
+      address.destroy!
+    end
+  end
+
+  test 'reindex! deleted removed records' do
+    a1 = Address.create(name: 'one')
+    a2 = Address.create(name: 'two')
+
+    assert_no_difference 'Runestone::Model.count' do
+      a2.delete
+    end
+
+    assert_difference 'Runestone::Model.count', -1 do
+      Address.reindex!
+    end
+  end
+
+  test 'reindex! updates runestones on outdated indexes' do
+    address = Address.create(name: 'one')
+    address.update_columns(name: 'two')
+
+    assert_equal(["'one':1A"], address.runestones.map(&:vector))
+    assert_no_difference 'Runestone::Model.count' do
+      Address.reindex!
+    end
+    assert_equal(["'two':1A"], address.runestones.map { |rs| rs.reload.vector })
+  end
+
+  test 'reindex! creates index if not there' do
+    address = Address.create(name: 'one')
+    address.runestones.each(&:delete)
+
+    assert_equal 0, address.reload.runestones.size
+    assert_difference 'Runestone::Model.count', 1 do
+      Address.reindex!
+    end
+    assert_equal(["'one':1A"], address.reload.runestones.map(&:vector))
+  end
+  
+end

data/test/query_test.rb

@@ -0,0 +1,129 @@
+require 'test_helper'
+
+class QueryTest < ActiveSupport::TestCase
+
+  test '::search(query)' do
+    query = Runestone::Model.search('seaerch for this')
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & this:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch & for & this:*')
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test '::search(query) normalizes Unicode strings' do
+    query = Runestone::Model.search("the search for \u0065\u0301")
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'the & search & for & \u00e9:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'the & search & for & \u00e9:*')
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test "::search(query with ')" do
+    query = Runestone::Model.search("seaerch for ' this")
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & this:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch & for & this:*')
+      ORDER BY rank0 DESC
+    SQL
+    
+    query = Runestone::Model.search("seaerch for james' map")
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & james'' & map:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch & for & james'' & map:*')
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test '::search(query, prefix: :all)' do
+    query = Runestone::Model.search('seaerch for this', prefix: :all)
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch:* & for:* & this:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch:* & for:* & this:*')
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test '::search(query).limit(N)' do
+    query = Runestone::Model.search('seaerch for this').limit(10)
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT "runestones".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & this:*')) AS rank0
+      FROM "runestones"
+      WHERE "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch & for & this:*')
+      ORDER BY rank0 DESC
+      LIMIT 10
+    SQL
+  end
+  
+  test 'Model::search(query)' do
+    query = Property.search('seaerch for this')
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "properties".*, ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & this:*')) AS rank0
+      FROM "properties"
+      INNER JOIN "runestones"
+        ON "runestones"."record_id" = "properties"."id"
+        AND "runestones"."record_type" = 'Property'
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', 'seaerch & for & this:*')
+      ORDER BY rank0 DESC
+    SQL
+  end
+  
+  test 'Model::search(query) with misspelling in query' do
+    Runestone::Corpus.add('search')
+    query = Property.search('seaerch for this')
+
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "properties".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'seaerch & for & this:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(seaerch | search) & for & this:*')) AS rank1
+      FROM "properties"
+      INNER JOIN "runestones" ON
+        "runestones"."record_id" = "properties"."id"
+        AND "runestones"."record_type" = 'Property'
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(seaerch | search) & for & this:*')
+      ORDER BY
+        rank0 DESC,
+        rank1 DESC
+    SQL
+  end
+  
+  test "::typos with special chars" do
+    Runestone::Corpus.add(*%w{avenue aveneue avenue)})
+    
+    words = "AVENUE AV AVE AVN AVEN AVENU AVNUE".split(/\s+/)
+    words.each do |word|
+      Runestone.add_synonym(word, *words.select { |w| w != word })
+    end
+
+    assert_sql(<<~SQL, Runestone::Model.search('avenue').to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'avenue:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(avenue:* | aveneue)')) AS rank1,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '((avenue:* | aveneue) | av | ave | avn | aven | avenu | avnue)')) AS rank2
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '((avenue:* | aveneue) | av | ave | avn | aven | avenu | avnue)')
+      ORDER BY
+        rank0 DESC,
+        rank1 DESC,
+        rank2 DESC
+    SQL
+  end
+
+end

data/test/synonym_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+class SynonymTest < ActiveSupport::TestCase
+
+  test '::synonyms' do
+    Runestone.add_synonyms({
+      '17' => %w(17th seventeen seventeenth),
+      'spruce' => %w(pine)
+    })
+
+    query = Runestone::Model.search('17 spruce')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '17 & spruce:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+  
+  test '::synonyms expanded to two words' do
+    Runestone.add_synonyms({
+      'supernovae' => ['super novae']
+    })
+
+    assert_equal "(supernovae:* | (super <1> novae))", Runestone::WebSearch.parse('supernovae').synonymize.to_s
+  end
+
+  test '::synonyms are evaluated in lowercase' do
+    Runestone.add_synonyms({
+      '17' => %w(17th seventeen seventeenth),
+      'spruce' => %w(pine)
+    })
+    query = Runestone::Model.search('17 Spruce')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '17 & spruce:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+
+  test '::not with synonyms' do
+    Runestone.add_synonyms({
+      '17' => %w(17th seventeen seventeenth),
+      'spruce' => %w(pine)
+    })
+    query = Runestone::Model.search('17 -spruce')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '17 & !spruce')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & !spruce')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & !spruce')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+
+  test '::synonym in quotes' do
+    Runestone.add_synonyms({
+      '17' => %w(17th seventeen seventeenth),
+      'spruce' => %w(pine)
+    })
+    query = Runestone::Model.search('17 "spruce"')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '17 & spruce')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & spruce')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & spruce')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+  
+  test '::synonym expanded for misspellings' do
+    Runestone::Corpus.add(*%w{17 seventeen spruce pine plne})
+    Runestone.add_synonyms({
+      '17' => %w(17th seventeen seventeenth),
+      'spruce' => %w(pine)
+    })
+    query = Runestone::Model.search('17 spruce')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '17 & spruce:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '(17 | 17th | seventeen | seventeenth) & (spruce:* | pine)')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+
+  test '::synonym phrase substitution' do
+    Runestone.add_synonyms({
+      'one hundred' => ['100', 'one hundy']
+    })
+    query = Runestone::Model.search('one hundred spruce')
+    
+    assert_sql(<<~SQL, query.to_sql)
+      SELECT
+        "runestones".*,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', 'one & hundred & spruce:*')) AS rank0,
+        ts_rank_cd("runestones"."vector", to_tsquery('simple_unaccent', '((one & hundred | 100) & spruce:* | (one & hundred | one hundy) & spruce:*)')) AS rank1
+      FROM "runestones"
+      WHERE
+        "runestones"."vector" @@ to_tsquery('simple_unaccent', '((one & hundred | 100) & spruce:* | (one & hundred | one hundy) & spruce:*)')
+      ORDER BY rank0 DESC, rank1 DESC
+    SQL
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,185 @@
+# To make testing/debugging easier, test within this source tree versus an
+# installed gem
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter %r{^/test/}
+  # add_group 'lib', 'sunstone/lib'
+  # add_group 'ext', 'sunstone/ext'
+end
+
+require "minitest/autorun"
+require 'minitest/unit'
+require 'minitest/reporters'
+require 'faker'
+require 'byebug'
+
+require 'active_record'
+require 'active_job'
+require 'active_job/test_helper'
+ActiveJob::Base.queue_adapter = :test
+require 'runestone'
+
+# Setup the test db
+ActiveSupport.test_order = :random
+require File.expand_path('../database', __FILE__)
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+$debugging = false
+
+# File 'lib/active_support/testing/declarative.rb', somewhere in rails....
+class ActiveSupport::TestCase
+  
+  include ActiveJob::TestHelper
+  
+  # File 'lib/active_support/testing/declarative.rb'
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
+    defined = method_defined? test_name
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        skip "No implementation provided for #{name}"
+      end
+    end
+  end
+
+  def teardown
+    super
+    Runestone.synonyms.clear
+    Runestone::Model.connection.execute('DELETE FROM runestone_corpus')
+    ActiveRecord::Base.subclasses.reject{|k| k.name.start_with?('ActiveRecord') }.each(&:delete_all)
+  end
+  
+  def debug
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    $debugging = true
+    yield
+  ensure
+    ActiveRecord::Base.logger = nil
+    $debugging = false
+  end
+
+  def capture_sql
+    # ActiveRecord::Base.connection.materialize_transactions
+    SQLLogger.clear_log
+    yield
+    SQLLogger.log_all.dup
+  end
+
+  def assert_sql(*patterns_to_match)
+    if patterns_to_match.all? { |s| s.is_a?(String) }
+      assert_equal(*patterns_to_match.take(2).map { |sql| sql.gsub(/( +|\n\s*|\s+)/, ' ').strip })
+    else
+      begin
+        ret_value = nil
+        capture_sql { ret_value = yield }
+        ret_value
+      ensure
+        failed_patterns = []
+        patterns_to_match.each do |pattern|
+          failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql }
+        end
+        assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
+      end
+    end
+  end
+
+  def assert_no_sql(*patterns_to_match)
+    if patterns_to_match.all? { |s| s.is_a?(String) }
+      assert_not_equal(*patterns_to_match.take(2).map { |sql| sql.gsub(/( +|\n\s*|\s+)/, ' ').strip })
+    else
+      begin
+        ret_value = nil
+        capture_sql { ret_value = yield }
+        ret_value
+      ensure
+        failed_patterns = []
+        patterns_to_match.each do |pattern|
+          failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql }
+        end
+        assert !failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
+      end
+    end
+  end
+  
+  def corpus
+    Runestone::Model.connection.execute('SELECT word FROM runestone_corpus ORDER BY word').values.flatten
+  end
+  
+  def assert_corpus(*words)
+    assert_equal words.flatten.sort, corpus
+  end
+  
+  def assert_corpus_has(*words)
+    assert_equal 0, (words - corpus).size
+  end
+  
+  class SQLLogger
+    class << self
+      attr_accessor :ignored_sql, :log, :log_all
+      def clear_log; self.log = []; self.log_all = []; end
+    end
+
+    self.clear_log
+
+    self.ignored_sql = [/^PRAGMA/i, /^SELECT currval/i, /^SELECT CAST/i, /^SELECT @@IDENTITY/i, /^SELECT @@ROWCOUNT/i, /^SAVEPOINT/i, /^ROLLBACK TO SAVEPOINT/i, /^RELEASE SAVEPOINT/i, /^SHOW max_identifier_length/i, /^BEGIN/i, /^COMMIT/i]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL, or better yet, use a different notification for the queries
+    # instead examining the SQL content.
+    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
+    mysql_ignored      = [/^SHOW FULL TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i, /^SHOW VARIABLES /, /^\s*SELECT (?:column_name|table_name)\b.*\bFROM information_schema\.(?:key_column_usage|tables)\b/im]
+    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select tablename\b.*from pg_tables\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
+    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im, /^\s*SELECT sql\b.*\bFROM sqlite_master/im]
+
+    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
+      ignored_sql.concat db_ignored_sql
+    end
+
+    attr_reader :ignore
+
+    def initialize(ignore = Regexp.union(self.class.ignored_sql))
+      @ignore = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name]
+
+      self.class.log_all << sql
+      unless ignore =~ sql
+        if $debugging
+        puts caller.select { |l| l.starts_with?(File.expand_path('../../lib', __FILE__)) }
+        puts "\n\n" 
+        end
+      end
+      self.class.log << sql unless ignore =~ sql
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLLogger.new)
+
+  # test/unit backwards compatibility methods
+  alias :assert_raise :assert_raises
+  alias :assert_not_empty :refute_empty
+  alias :assert_not_equal :refute_equal
+  alias :assert_not_in_delta :refute_in_delta
+  alias :assert_not_in_epsilon :refute_in_epsilon
+  alias :assert_not_includes :refute_includes
+  alias :assert_not_instance_of :refute_instance_of
+  alias :assert_not_kind_of :refute_kind_of
+  alias :assert_no_match :refute_match
+  alias :assert_not_nil :refute_nil
+  alias :assert_not_operator :refute_operator
+  alias :assert_not_predicate :refute_predicate
+  alias :assert_not_respond_to :refute_respond_to
+  alias :assert_not_same :refute_same
+  
+end