unit_record 0.1.0

data/README

@@ -0,0 +1,69 @@
+= UnitRecord
+
+This plugin provides unit testing for ActiveRecord by disconnecting tests from the database.
+
+== The Benefits
+
+Rationale: http://www.dcmanges.com/blog/rails-unit-record-test-without-the-database
+
+One huge benefit to disconnecting unit tests from the database is having a faster test suite.  Here is the benchmark from my current ThoughtWorks project:
+
+  Finished in 11.541093 seconds.
+  3001 tests, 5325 assertions, 0 failures, 0 errors
+
+== Requirements
+
+* Rails >= 1.2
+
+== Installation
+
+The traditional way:
+  ruby script/plugin install http://unit-test-ar.rubyforge.org/svn/trunk/unit_record/
+
+Or with piston:
+  piston import http://unit-test-ar.rubyforge.org/svn/trunk/unit_record/ vendor/plugins/unit_record
+
+== Usage
+
+=== Restructuring the Rails Test Directory
+
+The Rails test directory typically places testing for models under <tt>test/unit</tt> and tests for controllers under <tt>test/functional</tt>.  However, we need to change the definition of unit and functional.  Controllers can be unit tested (mocking out models and not rendering the view).  Models can be functionally tested (hitting the database).  Also, each type of test needs its own test_helper.  You should restructure your test directory like this:
+  test
+    test_helper.rb
+    unit
+      unit_test_helper.rb
+      controllers
+      models
+    functional
+      functional_test_helper.rb
+      controllers
+      models
+
+You should move existing functional tests into functional/controllers.  You will also need to change the require line at the top of those tests to require the functional_test_helper.rb file instead of the test_helper.rb file.
+
+The <tt>functional_test_helper.rb</tt> file should require <tt>test_helper.rb</tt> for now:
+  require File.dirname(__FILE__) + "/../test_helper"
+
+For moving unit tests, you have a few options.  I recommend moving them to unit/models and then disconnecting your unit tests from the database.  Any tests that fail should then be modified to not hit the database or moved to functional/models.
+
+== Caching Columns
+
+The plugin disconnects models from the database by caching the column metadata.  This is done through a rake task:
+  rake db:columns:dump
+
+The rake task creates a db/columns.rb file which will be used in the tests.  If you have a custom build/test rake task, you may just want to insert this task before you run your unit tests.  Otherwise, you can automatically have it run before <tt>test:units</tt> as so:
+  Rake::Task["test:units"].enhance ["db:columns:dump"]
+
+== Disconnecting
+
+In the <tt>test/unit/unit_test_helper.rb</tt> file you created when restructuring your test directory, you should add these lines:
+  require File.dirname(__FILE__) + "/../test_helper"
+  ActiveRecord::Base.disconnect!
+  
+The <tt>disconnect!</tt> method will do everything necessary (including loading the columns.rb file) to run your unit tests without hitting the database.
+
+== Thanks
+Thanks to Jay Fields for the original implementation:
+http://blog.jayfields.com/2007/03/rails-activerecord-unit-testing-part-ii.html
+
+Copyright (c) 2007 Dan Manges, released under the MIT license.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+desc "Default: run tests"
+task :default => :test
+
+desc "Run all tests"
+task :test => %w[test:caching test:disconnecting]
+
+desc "Run the tests for caching columns"
+Rake::TestTask.new("test:caching") do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/caching/**/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run the tests for disconnecting"
+Rake::TestTask.new("test:disconnecting") do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/disconnecting/**/*_test.rb'
+  t.verbose = true
+end
+
+desc "Generate documentation"
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.title    = "UnitRecord"
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README')
+end
+
+desc "Upload RDoc to RubyForge"
+task :publish_rdoc => [:rdoc] do
+  Rake::SshDirPublisher.new("dcmanges@rubyforge.org", "/var/www/gforge-projects/unit-test-ar", "doc").upload
+end
+
+Gem::manage_gems
+
+specification = Gem::Specification.new do |s|
+	s.name   = "unit_record"
+  s.summary = "UnitRecord enables unit testing without hitting the database."
+	s.version = "0.1.0"
+	s.author = "Dan Manges"
+	s.description = "UnitRecord enables unit testing without hitting the database."
+	s.email = "daniel.manges@gmail.com"
+  s.homepage = "http://unit-test-ar.rubyforge.org"
+  s.rubyforge_project = "unit-test-ar"
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README']
+  s.rdoc_options << '--title' << "UnitRecord" << '--main' << 'README' << '--line-numbers'
+
+  s.autorequire = "unit_record"
+  s.files = FileList['{lib,test}/**/*.rb', '^[A-Z]+$', 'Rakefile', 'init.rb'].to_a
+end
+
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = false
+  package.need_tar = false
+end

data/init.rb

@@ -0,0 +1 @@
+require "unit_record"

data/lib/unit_record/column_dumper.rb

@@ -0,0 +1,52 @@
+require 'erb'
+module UnitRecord
+  class ColumnDumper
+    private_class_method :new
+    
+    def self.dump(connection, stream)
+      new(connection).write_to(stream)
+    end
+    
+    def initialize(connection)
+      @connection = connection
+    end
+    
+    def columns_by_model
+      @columns_by_model ||= tables.inject({}) do |hash,table|
+        model = model_for_table(table)
+        hash[model.to_s] = columns(table) if model
+        hash
+      end
+    end
+    
+    def columns(table)
+      @connection.columns(table)
+    end
+    
+    def model_for_table(table)
+      table.classify.constantize rescue nil
+    end
+    
+    def tables
+      @connection.tables
+    end
+    
+    def write_to(stream)
+      template = ERB.new <<-END, nil, '-'
+<% columns_by_model.keys.sort.each do |model| -%>
+<%= model %>.class_eval do
+  def self.columns
+    [
+      <%- columns_by_model[model].each do |column| -%>
+      ActiveRecord::ConnectionAdapters::Column.new(<%= column.name.to_s.inspect %>, <%= column.default.inspect %>, <%= column.sql_type.inspect %>, <%= column.null.inspect%>),
+      <%- end -%>
+    ]
+  end
+end
+<%- end -%>
+END
+      text = template.result binding
+      stream.write text
+    end
+  end
+end

data/lib/unit_record/disconnected_active_record.rb

@@ -0,0 +1,28 @@
+module UnitRecord
+  module DisconnectedActiveRecord
+    def disconnected?
+      false
+    end
+    def disconnect!
+      return if disconnected?
+      columns_file = File.join(RAILS_ROOT, "db", "columns.rb")
+      File.open(columns_file, "w") do |file|
+        UnitRecord::ColumnDumper.dump(ActiveRecord::Base.connection, file)
+      end
+      (class << self; self; end).class_eval do
+        def connection
+          raise "ActiveRecord is disconnected; database access is unavailable in unit tests."
+        end
+        def connected?
+          false
+        end
+        def disconnected?
+          true
+        end
+      end
+      load columns_file
+      Fixtures.disconnect!
+      Test::Unit::TestCase.disconnect!
+    end
+  end
+end

data/lib/unit_record/disconnected_fixtures.rb

@@ -0,0 +1,9 @@
+module UnitRecord
+  module DisconnectedFixtures
+    def disconnect!
+      (class << self; self; end).class_eval do
+        def create_fixtures(*args); end
+      end
+    end
+  end
+end

data/lib/unit_record/disconnected_test_case.rb

@@ -0,0 +1,7 @@
+module UnitRecord
+  module DisconnectedTestCase
+    def disconnect!
+      self.use_transactional_fixtures = false
+    end
+  end
+end

data/lib/unit_record.rb

@@ -0,0 +1,8 @@
+require "unit_record/column_dumper"
+require "unit_record/disconnected_active_record"
+require "unit_record/disconnected_test_case"
+require "unit_record/disconnected_fixtures"
+ActiveRecord::Base.extend UnitRecord::DisconnectedActiveRecord
+Test::Unit::TestCase.extend UnitRecord::DisconnectedTestCase
+require "active_record/fixtures"
+Fixtures.extend UnitRecord::DisconnectedFixtures

data/test/caching/column_dumper_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ColumnDumperTest < Test::Unit::TestCase
+  test "dumping columns" do
+    stream = StringIO.new
+    UnitRecord::ColumnDumper.dump(ActiveRecord::Base.connection, stream)
+    expected = <<-END
+Person.class_eval do
+  def self.columns
+    [
+      ActiveRecord::ConnectionAdapters::Column.new("id", nil, "INTEGER", false),
+      ActiveRecord::ConnectionAdapters::Column.new("first_name", nil, "varchar(255)", true),
+      ActiveRecord::ConnectionAdapters::Column.new("last_name", nil, "varchar(255)", true),
+    ]
+  end
+end
+END
+    assert_equal expected, stream.string
+  end
+end

data/test/db/columns.rb

@@ -0,0 +1,9 @@
+Person.class_eval do
+  def self.columns
+    [
+      ActiveRecord::ConnectionAdapters::Column.new("id", nil, "INTEGER", false),
+      ActiveRecord::ConnectionAdapters::Column.new("first_name", nil, "varchar(255)", true),
+      ActiveRecord::ConnectionAdapters::Column.new("last_name", nil, "varchar(255)", true),
+    ]
+  end
+end

data/test/disconnecting/disconnected_active_record_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/./disconnecting_test_helper"
+# The '.' is intentional to have a TestCase require a different relative path.
+
+class DisconnectedActiveRecordTest < Test::Unit::TestCase
+  test "accessing connection raises" do
+    assert_raises(RuntimeError) { ActiveRecord::Base.connection }
+  end
+  
+  test "connected? is false" do
+    assert_equal false, ActiveRecord::Base.connected?
+  end
+  
+  test "disconnected? is true" do
+    assert_equal true, ActiveRecord::Base.disconnected?
+  end
+end

data/test/disconnecting/disconnected_fixtures_test.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + "/disconnecting_test_helper"
+
+class DisconnectedTestCaseTest < Test::Unit::TestCase  
+  test "create_fixtures does nothing" do
+    assert_nothing_raised { Fixtures.create_fixtures }
+  end
+end

data/test/disconnecting/disconnected_test_case_test.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + "/disconnecting_test_helper"
+
+class DisconnectedTestCaseTest < Test::Unit::TestCase  
+  test "use_transactional_fixtures is false" do
+    assert_equal false, Test::Unit::TestCase.use_transactional_fixtures
+  end
+end

data/test/disconnecting/disconnecting_test_helper.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/../test_helper" unless defined?(RAILS_ROOT)
+ActiveRecord::Base.disconnect!

data/test/schema.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :people do |t|
+    t.column :first_name, :string
+    t.column :last_name,  :string
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support/binding_of_caller'
+require 'active_support/breakpoint'
+begin
+  require 'mocha'
+  require 'dust'
+rescue LoadError
+  raise "Need Mocha and Dust gems to Test"
+end
+
+ActiveRecord::Base.configurations['test'] = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'][ENV['DB'] || 'sqlite3'])
+
+require "#{File.dirname(__FILE__)}/../init"
+silence_stream(STDOUT) do
+  load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
+end
+
+Test::Unit::TestCase.use_transactional_fixtures = true
+
+class Person < ActiveRecord::Base
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.3
+specification_version: 1
+name: unit_record
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-08-15 00:00:00 -04:00
+summary: UnitRecord enables unit testing without hitting the database.
+require_paths: 
+- lib
+email: daniel.manges@gmail.com
+homepage: http://unit-test-ar.rubyforge.org
+rubyforge_project: unit-test-ar
+description: UnitRecord enables unit testing without hitting the database.
+autorequire: unit_record
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dan Manges
+files: 
+- lib/unit_record.rb
+- lib/unit_record/column_dumper.rb
+- lib/unit_record/disconnected_active_record.rb
+- lib/unit_record/disconnected_fixtures.rb
+- lib/unit_record/disconnected_test_case.rb
+- test/schema.rb
+- test/test_helper.rb
+- test/caching/column_dumper_test.rb
+- test/db/columns.rb
+- test/disconnecting/disconnected_active_record_test.rb
+- test/disconnecting/disconnected_fixtures_test.rb
+- test/disconnecting/disconnected_test_case_test.rb
+- test/disconnecting/disconnecting_test_helper.rb
+- Rakefile
+- init.rb
+- README
+test_files: []
+
+rdoc_options: 
+- --title
+- UnitRecord
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+