assert_efficient_sql 0.3.0 → 0.3.1

data/lib/assert_efficient_sql.rb

@@ -8,7 +8,7 @@ require 'assert2'
   #  ERGO  check for valid options
   #  ERGO  highlite the offending row in the analysis
   #  ERGO  cite http://hackmysql.com/selectandsort
-#  ERGO  link from http://efficient-sql.rubyforge.org/files/README.html to 
+#  ERGO  link from http://efficient-sql.rubyforge.org/files/README.html to
 #        project page
 # ERGO hamachi.cc
 #  ERGO  is flunk susceptible to <?> bug?
@@ -60,7 +60,7 @@ module ActiveRecord
 
 #  TODO  use extended?
 #  http://www.mysqlperformanceblog.com/2006/07/24/extended-explain/
-#  
+#
 # ERGO          p select_without_analyzer('show warnings')
 #         hence, show warnings caused by your queries, too
 
@@ -73,7 +73,7 @@ module ActiveRecord
                 end
               ) if sql =~ /^select/i
             end
-            
+
             explained = [sql, name, analysis.map(&:with_indifferent_access)]
             (@analyses ||= []) << explained
           end
@@ -87,14 +87,14 @@ end
 module AssertEfficientSql; end
 
 class AssertEfficientSql::SqlEfficiencyAsserter
-  
+
   def initialize(options, context)
     @issues = []
     @options, @context = options, context
     @analyses = ActiveRecord::Base.connection.analyses
     @session_before = fetch_database_session
     yield
-    check_for_query_statements    
+    check_for_query_statements
     @session_after = fetch_database_session
     check_session_status
 
@@ -103,7 +103,7 @@ class AssertEfficientSql::SqlEfficiencyAsserter
         analyze_efficiency
       end
     end
-    
+
     puts explain_all  if @options[:verbose]
   end
 
@@ -138,27 +138,27 @@ class AssertEfficientSql::SqlEfficiencyAsserter
       end
     end
   end
-  
+
   def analyze_efficiency
     rows = @explanation[:rows].to_i
     throttle = @options[:throttle]
-    
+
     check rows <= throttle do
       "row count #{ rows } is more than :throttle => #{ throttle }"
     end
-  
-    check @options[:ALL] || 'ALL' != @explanation[:type] do  
-      'full table scan'  
+
+    check @options[:ALL] || 'ALL' != @explanation[:type] do
+      'full table scan'
     end
-    
+
     check @options[:Using_filesort] ||
           @explanation[:Extra] !~ /(Using filesort)/ do
       $1
     end
-    
+
     flunk 'Pessimistic ' + format_explanation  unless @issues.empty?
   end
-  
+
   def check_for_query_statements
     flunk 'assert_efficient_sql saw no queries!'  if @analyses.empty?
   end
@@ -166,35 +166,37 @@ class AssertEfficientSql::SqlEfficiencyAsserter
   def flunk(why)
     @context.flunk @context.build_message(@options[:diagnostic], why)
   end
-  
+
   def format_explanation
     @name = 'for ' + @name  unless @name.blank?
 
     return "\nquery #{ @name }\n" +
            @issues.join("\n") +
-           "\n#{ @sql }\n   " + 
+           "\n#{ @sql }\n   " +
            @analysis.qa_columnized
   end
 
 end
-  
+
 #:startdoc:
 
 
 module AssertEfficientSql
-  
-  #  See: http://www.oreillynet.com/onlamp/blog/2007/07/assert_latest_and_greatest.html
- 
+
+  #  This collects every model in the given class that appears while its block runs
   def assert_latest(*models, &block)
     models, diagnostic = _get_latest_args(models, 'assert')
-    get_latest(models, &block) or _flunk_latest(models, diagnostic, true, block)
+    latests = get_latest(models, &block)
+    latests.compact.length == models.length or
+      _flunk_latest(models, latests, diagnostic, true, block)
+    return *latests
   end
 
-  def _get_latest_args(models, what)
+  def _get_latest_args(models, what) #:nodoc:
     diagnostic = nil
     diagnostic = models.pop if models.last.kind_of? String
-  
-    unless models.length > 0 and 
+
+    unless models.length > 0 and
             (diagnostic.nil? or diagnostic.kind_of? String)
       raise "call #{ what }_latest(models..., diagnostic) with any number " +
             'of Model classes, followed by an optional diagnostic message'
@@ -202,49 +204,55 @@ module AssertEfficientSql
     return models, diagnostic
   end
   private :_get_latest_args
-  
+
   def deny_latest(*models, &block)
     models, diagnostic = _get_latest_args(models, 'deny')
-    return unless got = get_latest(models, &block)
-    models = [got].flatten.compact.map(&:class)
-   _flunk_latest(models, diagnostic, false, block)
+    latests = get_latest(models, &block)
+    return if latests.compact.empty?
+    models = [latests].flatten.compact.map(&:class)
+   _flunk_latest(models, latests, diagnostic, false, block)
   end
 
   def get_latest(models, &block)
     max_ids = models.map{|model| model.maximum(:id) || 0 }
     block.call
     index = -1
-    return *models.map{|model|
+    return models.map{|model|
       all = *model.find( :all,
                         :conditions => "id > #{max_ids[index += 1]}",
                         :order => "id asc" )
-      all # * returns nil for [], 
-            #     one object for [x], 
+      all # * returns nil for [],
+           #     one object for [x],
             #     or an array with more than one item
     }
   end
-  
-  def _flunk_latest(models, diagnostic, polarity, block)
-    model_names = models.map(&:name).join(', ')
-    rationale = "should#{ ' not' unless polarity 
+
+  def _flunk_latest(models, latests, diagnostic, polarity, block) #:nodoc:
+    model_names = models.map(&:name)
+    model_names.each_with_index do |it, index|
+      model_names[index] = nil if !!latests[index] == polarity
+    end
+    model_names = model_names.compact.join(', ')
+    rationale = "should#{ ' not' unless polarity
                  } create new #{ model_names
-                 } record(s) in block:\n\t\t#{ 
-                    reflect_source(&block).gsub("\n", "\n\t\t") 
+                 } record(s) in block:\n\t\t#{
+                    reflect_source(&block).gsub("\n", "\n\t\t")
                  }\n"
 #                 RubyNodeReflector::RubyReflector.new(block, false).result }"
                  # note we don't evaluate...
     flunk build_message(diagnostic, rationale)
   end
   private :_flunk_latest
-  
-  
+
+
   def _exec(cmd) #:nodoc:
     ActiveRecord::Base.connection.execute(cmd)
   end
 
+  #  See: http://www.oreillynet.com/onlamp/blog/2007/07/assert_latest_and_greatest.html
   def assert_efficient_sql(options = {}, &block)
     options = { :verbose => true } if options == :verbose
-    
+
     if options.class == Hash
       options.reverse_merge! default_options
 
@@ -257,13 +265,83 @@ module AssertEfficientSql
     else
       print_syntax
     end
-    
+
     return []
   end
 
+  def self._singulars #:nodoc:
+    return [ [:ids,     :id    ],  [:key_lens,     :key_len    ],
+             [:keys,    :key   ],  [:refs,         :ref        ],
+             [:rows,    :rows  ],  [:select_types, :select_type],
+             [:tables,  :table ],  [:types,        :type       ] ]
+  end
+
+  def self._multiples #:nodoc:
+    return [ [:extras,        :Extra        ],
+             [:possible_keys, :possible_keys] ]
+  end
+
+  #   def test_order_transactions_by_id
+  #     sqls = inspect_sql :match => /SELECT conversations.\*/ do
+  #       get_sales_after_transaction_id
+  #     end
+  #     statement = sqls.first[:statement]
+  #     assert{ statement =~ /ORDER BY id asc/ }
+  #   end
+  #
+  def inspect_sql(options = {}, &block)
+    verbose = options.fetch(:verbose, false)
+    match   = options.fetch(:match, /./)
+    args    = { :ALL => true, :Using_filesort => true, :verbose => verbose }
+    inspections = assert_efficient_sql(args, &block)
+      # pp inspections.first
+
+    explains = inspections.inject([]) do |a, inspection|
+      if inspection.first =~ match
+        explanations = inspection.last
+
+        h = { :statement => inspection.first,
+              :explanations => explanations }
+
+        AssertEfficientSql._singulars.each do |rollup, explainer|
+          h[rollup] = explanations.map{|e| q = e[explainer] and q.to_sym }
+        end
+
+        AssertEfficientSql._multiples.each do |rollup, explainer|
+          h[rollup] = explanations.map do |e|
+                        q = e[explainer]
+                        [q].flatten.map do |e|
+                          e and
+                          e.any? and
+                          (rollup == :extras ? e.gsub!(' ', '_') : e ) and
+                          e.to_sym
+                        end
+                      end
+        end
+        a << h
+      end
+      a
+    end
+    return AssertEfficientSql._decorate_explainers(explains)
+  end
+
+  def self._decorate_explainers(explains) #:nodoc:
+    def explains.find_statements(regexp)
+      return AssertEfficientSql._decorate_explainers(select{|explanation|
+        explanation[:statement] =~ regexp
+      })
+    end
+
+    (_multiples + _singulars).each do |rollup, explainer|
+      eval "def explains.#{rollup}; map{|q|q[:#{rollup}]}.flatten.uniq; end"
+    end
+
+    return explains
+  end  #  FIXME  gotta be private
+
   class BufferStdout #:nodoc:
     def write(stuff)
-      (@output ||= '') << stuff  
+      (@output ||= '') << stuff
     end
     def output;  @output || ''  end
   end
@@ -284,19 +362,19 @@ module AssertEfficientSql
   end
 
   private
-  
+
     def current_adapter?(type) #:nodoc:
       ActiveRecord::ConnectionAdapters.const_defined?(type) and
         ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
     end
-    
+
     def warn_adapter_required(options)
       if options[:warn_mysql_required]
         puts 'assert_efficient_sql requires MySQL' unless $warned_once
         $warned_once = true
-      end  
+      end
     end
-    
+
     def assert_efficient_mysql(options, &block)
       outer_block_analyses = ActiveRecord::Base.connection.analyses
       ActiveRecord::Base.connection.analyses = []
@@ -306,7 +384,7 @@ module AssertEfficientSql
     ensure
       ActiveRecord::Base.connection.analyses = outer_block_analyses
     end
-    
+
     def syntax
       return {
         :diagnostic          => [nil  , 'supplementary message in failure reports'],
@@ -316,22 +394,22 @@ module AssertEfficientSql
         :verbose             => [false, 'if the test passes, print the EXPLAIN'],
         :warn_mysql_required => [true , 'disable the spew advising we only work with MySQL'] }
     end
-    
+
     def default_options
       options = syntax.dup
       options.each{|k,(v,m)| options[k] = v}
       return options
     end
-    
+
     def print_syntax
       puts "\n\nassert_efficient_sql called with invalid argument.\n"
       puts "  __flag__            __default__  __effect__"
-    
+
       syntax.each do |k,(v,m)|
         printf "   :%-14s =>   %-8s # %s\n", k, v.inspect, m
       end
     end
-  
+
 end
 
 #:stopdoc:

data/test/assert_efficient_sql_test.rb

@@ -0,0 +1,384 @@
+
+#:stopdoc:
+
+require 'rubygems'
+require 'active_record'
+require 'active_record/connection_adapters/mysql_adapter.rb'
+require 'test/unit'
+require 'pathname'
+require 'yaml'
+require 'optparse'
+require 'erb'
+Assert_efficient_sql_root = (Pathname.new(__FILE__).expand_path.dirname + '..').expand_path
+load Assert_efficient_sql_root + 'lib/assert_efficient_sql.rb'
+
+#  ERGO even work if you are sqLite3
+class Foo < ActiveRecord::Base;  end
+class T2 < ActiveRecord::Base;  self.table_name ='t2';  end
+
+#:startdoc:
+
+class AssertEfficientSqlTest < Test::Unit::TestCase
+
+  def setup #:nodoc:
+    config_file = (Assert_efficient_sql_root + 'config/database.yml').to_s
+    config = YAML.load(ERB.new(IO.read(config_file)).result)['test']
+    ActiveRecord::Base.establish_connection(config)
+
+    ActiveRecord::Base.connection.
+      create_table(:foos) do |t|
+        t.column :name, :string, :limit => 60
+      end
+
+    43.times{  Foo.create!(:name => 'whatever')  }
+    _exec %[ CREATE TABLE `t2` (
+               `id` int(11) auto_increment,
+               `a` int(11) NOT NULL DEFAULT '0',
+               `b` blob,
+               `c` int(11) NOT NULL,
+                PRIMARY KEY (id)
+             ) ENGINE=InnoDB ] rescue nil
+    #system('mysql -u root beast_test')
+  end
+
+  # If +assert_efficient_sql+ (generally) dislikes your arguments,
+  # it will print out its default options, each with an explanation
+  #
+  def test_help
+    assert_stdout /invalid.*argument.*
+                   verbose .* =\> .* false/mx do
+      assert_efficient_sql(:help){}
+    end
+  end
+
+  def test_assert_efficient_sql
+    assert_efficient_sql{  Foo.find(2)  }
+  end
+
+  # If your SQL is already efficient, use <b>:verbose</b> to diagnose
+  # <i>why</i> it's efficient.
+  #
+  def test_verbose
+    assert_stdout /select_type/ do
+      assert_efficient_sql :verbose do
+        Foo.find_by_id(42)
+      end
+    end
+  end
+
+  # If your block did not call any SQL SELECT statements,
+  # you probably need a warning!
+  #
+  def test_require_sql
+    assert_flunked /no queries/ do
+      assert_efficient_sql{}
+    end
+  end
+
+  # This test case uses
+  # <code>assert_raise_message[http://www.oreillynet.com/onlamp/blog/2007/07/assert_raise_on_ruby_dont_just.html]</code>
+  # to demonstrate <code>assert_efficient_sql</code> failing:
+  #
+  def test_assert_inefficient_sql
+    assert_flunked /Pessimistic.*
+                    full.table.scan.*
+                    Foo.Load/mx do
+      assert_efficient_sql do
+        Foo.find_by_sql('select * from foos a')
+      end
+    end
+  end
+
+  # One common pessimization is a query that reads thousands
+  # of rows just to return a few. +assert_efficient_sql+
+  # counts the rows hit in each phase of an SQL +SELECT+,
+  # and faults if any row count exceeds <b>1,000</b>.
+  #
+  # Adjust this count with <b><code>:throttle => 42</code></b>.
+  #
+  def test_throttle
+    101.times{|x|  Foo.create :name => "foo_#{ x }"  }
+
+    assert_flunked /Pessimistic.*
+                    more.than.*100.*
+                    Foo.Load/mx do
+      assert_efficient_sql :throttle => 100, :ALL => true do
+        Foo.find(:all)
+      end
+    end
+  end
+
+  # Sometimes you need an +ALL+, even while other <code>assert_efficient_sql</code>
+  # checks must pass. To positively declare we like +ALL+, pass it as the key of a
+  # +true+ option into the assertion:
+  #
+  def test_assert_all
+    assert_efficient_sql :ALL => true do
+      Foo.find(:all)
+    end
+  end
+
+  # If your +WHERE+ and +ORDER+ clauses are too complex,
+  # MySQL might need to write a file (or worse), just to
+  # satisfy a query. +assert_efficient_sql+ detects this
+  # pernicious situation:
+  #
+  def test_prevent_filesorts
+    _exec %[ CREATE TABLE `t1` (
+               `a` int(11) NOT NULL DEFAULT '0',
+               `b` blob NOT NULL,
+               `c` text NOT NULL,
+               PRIMARY KEY (`a`,`b`(255),`c`(255)),
+               KEY `t1ba` (`b`(10),`a`)
+             ) ENGINE=InnoDB ]
+
+    assert_flunked /Using.filesort/ do
+      assert_efficient_sql do
+        Foo.find_by_sql('SELECT a FROM t1 ORDER BY b')
+      end
+    end
+  ensure
+    _exec 'drop table t1' # ERGO if exist
+  end
+
+  def test_ALL_with_possible_keys
+    assert_efficient_sql :ALL => true, :Using_filesort => true, :key => false do
+      Foo.find_by_sql('SELECT a FROM t2 ORDER BY c')
+    end
+  end
+
+  # <code>assert_efficient_sql</code> calls
+  # <code>SHOW SESSION STATUS</code> before and after
+  # its sampled block. If you need to prevent an advanced
+  # pessimization, such as <code>Created_tmp_disk_tables</code>,
+  # pass <code>:Created_tmp_disk_tables => 0</code>. The
+  # assertion will compare difference in STATUS before
+  # and after calling its block. A difference greater
+  # than the allowed difference will trigger a fault.
+  #
+  # To test this, we simply detect a STATUS variable
+  # which is not a warning.
+  #
+  def test_declare_futile_war_on_Innodb_rows_read
+    assert_flunked /just.for.test.*
+                    Innodb_rows_read/mx do
+      assert_efficient_sql :diagnostic => 'just for test!',
+                           :Innodb_rows_read => 0 do
+        Foo.find(:all)
+      end
+    end
+  end
+
+  #  You can also nest the assertion, to provide different
+  #  options for different blocks. The assertion allows
+  #  this because your test might also have some other
+  #  reason to use blocks
+  #
+  def test_nest
+    outer_result = assert_efficient_sql do
+      inner_result = assert_efficient_sql :ALL => true do
+        Foo.find(:all)
+      end
+
+      assert_no_match /where/i, inner_result[0][0]
+      Foo.find(42)
+    end
+    assert_match /where/i, outer_result[0][0]
+  end
+
+  def test_inspect_sql
+    inspections = inspect_sql do
+                    Foo.find_by_sql('SELECT id FROM t2 ORDER BY c')
+                    Foo.find_by_sql('SELECT c  FROM t2 ORDER BY a')
+                    Foo.find_by_sql('SELECT *  FROM foos, t2')
+                  end
+    assert{ inspections.length == 3 }
+    assert{ inspections[0][:statement]     == 'SELECT id FROM t2 ORDER BY c' }
+    assert{ inspections[0][:possible_keys] == [[nil]] }
+    assert{ inspections[0][:extras]        == [[:Using_filesort]] }
+    assert{ inspections[0][:types]         == [:ALL] }
+    assert{ inspections[1][:tables]        == [:t2] }
+    assert{ inspections[1][:possible_keys] == [[nil]] }
+    assert{ inspections[2][:tables]        == [:t2, :foos] } # note the order is constrained!
+    assert{ inspections[2][:possible_keys] == [[nil], [nil]] }
+    assert{ inspections[1][:keys]          == [nil] } # [:PRIMARY] }
+    assert{ inspections[2][:keys]          == [nil, nil] }
+  end
+
+  def test_inspect_sql_explanations
+    inspections = inspect_sql do
+                    Foo.find_by_sql('SELECT a FROM t2 ORDER BY c')
+                    Foo.find_by_sql('SELECT c FROM t2 ORDER BY a')
+                    Foo.find_by_sql('SELECT * FROM foos, t2')
+                  end
+    assert{ inspections.length == 3 }
+    assert{ inspections[0][:statement]     == 'SELECT a FROM t2 ORDER BY c' }
+    assert{ inspections[0][:explanations].first[:possible_keys] == nil   }
+    assert{ inspections[0][:explanations].first[:Extra]         == 'Using_filesort' }
+    assert{ inspections[0][:explanations].first[:type]          == 'ALL' }
+    assert{ inspections[1][:explanations].first[:table]         == 't2'  }
+    assert{ inspections[1][:explanations].first[:possible_keys] == nil   }
+    assert{ inspections[2][:explanations].first[:table]         == 't2'  } # note the order is constrained!
+    assert{ inspections[1][:explanations].first[:possible_keys] == nil   }
+    assert{ inspections[2][:explanations].first[:possible_keys] == nil   }
+  end
+
+  def test_inspect_sql_find_statements
+    inspections = inspect_sql do
+                    Foo.find_by_sql('SELECT a FROM t2 ORDER BY c')
+                    Foo.find_by_sql('SELECT c FROM t2 ORDER BY a')
+                    Foo.find_by_sql('SELECT * FROM foos, t2')
+                  end
+    inspections = inspections.find_statements(/from t2/i)
+    assert{ inspections[0][:statement] == 'SELECT a FROM t2 ORDER BY c' }
+    assert{ inspections[1][:explanations].first[:table] == 't2' }
+    deny{ inspections[2] }
+    assert{ inspections.tables == [:t2] }
+    #assert{ inspections.keys.to_set == [nil, :PRIMARY].to_set }
+  end
+
+  def test_inspect_certain_sql_statements
+    inspections = inspect_sql :match => /from t2/i do
+                    Foo.find_by_sql('SELECT a FROM t2 ORDER BY c')
+                    Foo.find_by_sql('SELECT c FROM t2 ORDER BY a')
+                    Foo.find_by_sql('SELECT * FROM foos, t2')
+                  end
+    assert{ inspections[0][:statement] == 'SELECT a FROM t2 ORDER BY c' }
+    assert{ inspections[1][:explanations].first[:table] == 't2' }
+    deny{ inspections[2] }
+  end
+
+  def test_inspect_sql_rollups
+    inspections = inspect_sql :verbose => false do
+                    Foo.find_by_sql('SELECT a FROM t2 ORDER BY c')
+                    Foo.find_by_sql('SELECT c FROM t2 ORDER BY a')
+                    Foo.find_by_sql('SELECT * FROM foos, t2')
+                  end
+    assert{ inspections.tables.to_set == [:t2, :foos].to_set }
+    assert{ inspections.keys.to_set == [nil].to_set }
+  end
+
+  def test_assert_latest
+    assert_flunked(/false/){ assert false }
+
+    assert_flunked /should create new Foo record\(s\) in/ do
+      assert_latest(Foo){ 'nada!' }
+    end
+
+    assert_flunked /because.*should not create new Foo record\(s\) in/m do
+      deny_latest Foo, 'because' do
+        Foo.create
+      end
+    end
+    nada = 42
+
+    assert_flunked /in block:\n.*nada/m do
+      assert_latest(Foo){ nada }
+    end
+
+    deny_flunked /42/ do  #  assert_latest shall not evaluate thy block
+      assert_latest(Foo){ nada }
+    end
+  end
+
+  def test_assert_polygamous_latest
+    f, t = assert_latest Foo, T2, 'diagnostic' do
+             Foo.create
+             T2.create(:c => 42)
+           end
+
+    assert{ f.id > 0 and t.id > 0 }
+
+    f1, f2 = assert_latest Foo do
+               2.times{ Foo.create }
+             end
+
+    assert 'items return ordered by id' do
+      f1.id > 0 and f2.id > f1.id
+    end
+
+    t, fz = assert_latest T2, Foo do
+              T2.create(:c => 42)
+              2.times{ Foo.create }
+            end
+
+    assert do
+      t.id > 0     and
+      fz[0].id > 0 and
+      fz[1].id > fz[0].id
+    end
+
+    t, (f1, f2) = assert_latest T2, Foo do
+              T2.create(:c => 42)
+              2.times{ Foo.create }
+            end
+
+    assert do
+       t.id > 0 and
+      f1.id > 0 and
+      f2.id > f1.id
+    end
+  end
+
+
+  def test_assert_polygamous_latest_fails
+    assert_flunked /diagnostic.*new T2 rcord/m do
+      f, t = assert_latest Foo, T2, 'diagnostic' do
+               Foo.create
+             end
+    end
+  end
+
+  def test_deny_polygamous_latest_fails
+    assert_flunked /diagnostic.*new Foo record/m do
+      f, t = deny_latest Foo, T2, 'diagnostic' do
+               Foo.create
+             end
+    end
+  end
+
+  def teardown #:nodoc:
+    ActiveRecord::Base.connection.drop_table(:foos)  rescue nil
+    ActiveRecord::Base.connection.drop_table(:t2)  rescue nil
+  end
+
+end
+
+#:enddoc:
+
+class AssertNonMysqlTest < Test::Unit::TestCase
+
+  #  The assertion requires MySQL. To peacefully coexist with
+  #  test rigs that use multiple adapters, we only warn, once,
+  #  if MySQL is not found. If you don't need this warning,
+  #  turn it off with :warn_mysql_required => false
+  #
+  def test_gently_forwarn_non_mysql_connectors
+    ActiveRecord::Base.establish_connection( :adapter => 'sqlite3',
+                                              :dbfile => ':memory:' )
+
+    deny_stdout /requires MySQL/, 'disabled warning' do
+      assert_efficient_sql :warn_mysql_required => false
+    end
+
+    assert_stdout /requires MySQL/, 'warn the first time' do
+      assert_efficient_sql
+    end
+
+    deny_stdout /requires MySQL/, 'don\'t warn the second time' do
+      assert_efficient_sql
+    end
+
+  ensure
+    config_file = (Assert_efficient_sql_root + 'config/database.yml').to_s
+    config = YAML.load(ERB.new(IO.read(config_file)).result)['test']
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+end
+
+
+def rails_root  #  ERGO  is this used?
+  return (Pathname.new(__FILE__).expand_path.dirname + '../../../..').expand_path
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assert_efficient_sql
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Phlip
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-12 00:00:00 -07:00
+date: 2008-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rubynode
+  name: assert2
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -22,7 +23,8 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: assert2
+  name: rubynode
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -39,6 +41,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- test/assert_efficient_sql_test.rb
 - lib/assert_efficient_sql.rb
 has_rdoc: false
 homepage: http://rubyforge.org/projects/efficient-sql
@@ -62,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: efficient-sql
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: efficient assertions for ActiveRecord tests