rsanheim-unit_record 0.9.0.1

data/CHANGELOG

@@ -0,0 +1,34 @@
+*HEAD
+
+* Add association stubbing with mocha
+
+  ActiveRecord::Base.disconnect! :stub_associations => true
+
+* Add option to no-op instead of raise.
+
+  ActiveRecord::Base.disconnect! :strategy => :noop
+  or
+  ActiveRecord::Base.disconnect! :strategy => :raise
+  
+* Implemented as a connection adapter
+
+*0.4.1* (December 10th, 2007)
+
+* Stub caching for compatibility with ActionController::Caching::SqlCache in Rails 2.
+
+*0.4.0* (December 9th, 2007)
+
+* Rails 2.0 compatibility.
+
+*0.3.0* (August 22nd, 2007)
+
+* Works with models using non-conventional table names.
+
+*0.2.0* (August 16th, 2007)
+
+* Cache columns based on schema.rb
+
+*0.1.0* (August 15th, 2007)
+
+* Converted plugin into a gem.
+* No longer depend on Rake task to dump and cache columns.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2008 Dan Manges
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,137 @@
+UnitRecord
+==========
+
+Enables unit testing ActiveRecord classes without hitting the database.
+
+Why?
+----
+
+Rationale: [http://www.dcmanges.com/blog/rails-unit-record-test-without-the-database](http://www.dcmanges.com/blog/rails-unit-record-test-without-the-database)
+
+One of the biggest benefits to disconnecting unit tests from the database is having a faster test suite.  Here is the benchmark from one of my current projects:
+
+    Finished in 19.302702 seconds.
+    4920 tests, 7878 assertions, 0 failures, 0 errors
+  
+4 seconds per 1,000 tests is a good guideline.
+
+Installation
+------------
+
+    gem install 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.  I recommend restructuring 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 only needs to require <tt>test_helper.rb</tt>:
+
+    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.
+
+Usage
+-----
+
+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"
+    require "unit_record"
+    ActiveRecord::Base.disconnect!
+  
+The <tt>disconnect!</tt> method will do everything necessary to run your unit tests without hitting the database.
+
+Strategy
+--------
+
+There are two options for what should happen if you hit the database. You can either have UnitRecord raise an exception, or simply no-op. Raising an exception can help identify why a test is failing, but it also may be inconvenient to work around.
+
+If you want to raise an exception:
+
+    ActiveRecord::Base.disconnect! :strategy => :raise
+    
+    Person.find(:all)
+    #=> RuntimeError: ActiveRecord is disconnected; database access is unavailable in unit tests.
+
+If you want to no-op:
+
+    ActiveRecord::Base.disconnect! :strategy => :noop
+    
+    Person.find(:all)
+    #=> []
+    
+You can also change strategies within a block:
+
+    ActiveRecord::Base.connection.change_strategy(:raise) do
+      Person.find(:all)
+      #=> RuntimeError: ActiveRecord is disconnected; database access is unavailable in unit tests.
+    end
+
+    ActiveRecord::Base.connection.change_strategy(:noop) do
+      Person.find(:all)
+      #=> []
+    end
+    
+Association Stubbing
+--------------------
+
+One painful aspect of unit testing ActiveRecord classes is setting associations. Because Rails does type checking when setting an association, you'll receive an exception if you try to use a stub in place of the expected class.
+
+    Pet.new :owner => stub("person")
+    #=> ActiveRecord::AssociationTypeMismatch: Person(#16620740) expected, got Mocha::Mock(#11567340)
+    
+If you're using mocha, you can have UnitRecord stub associations. To enable association stubbing:
+
+    ActiveRecord::Base.disconnect! :stub_associations => true
+
+The above example would no longer raise an exception. It would be the equivalent of:
+
+    pet = Pet.new
+    pet.stubs(:owner).returns(stub("person"))
+    
+Note that using this approach, the setter for the association will not work for that instance.
+
+Development
+-----------
+
+Active development occurs on the [GitHub](http://github.com/dan-manges/unit-record). Changes are also pushed to the Rubyforge git repository.
+
+For bugs/patches/etc please use the [Rubyforge tracker](http://rubyforge.org/tracker/?group_id=4239).
+
+Continuous integration is provided by [RunCodeRun](http://runcoderun.com/dan-manges/unit-record).
+
+Thanks
+------
+Thanks to Jay Fields for the [original implementation](http://blog.jayfields.com/2007/03/rails-activerecord-unit-testing-part-ii.html).
+
+Maintainer
+----------
+
+[Dan Manges](http://www.dcmanges.com)
+
+Contributors
+------------
+
+* David Lowenfels
+* Rob Sanheim
+
+License
+-------
+Released under the MIT license

data/Rakefile

@@ -0,0 +1,94 @@
+require 'rake'
+require 'rake/testtask'
+
+desc "Default: run tests"
+task :default => %w[test:multi_verbose spec]
+
+Rake::TestTask.new("test") do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+
+begin
+  require "rcov/rcovtask"
+  desc "run tests with rcov"
+  Rcov::RcovTask.new do |t|
+    t.pattern = "test/**/*_test.rb"
+    t.rcov_opts << ["--no-html", "--exclude 'Library,#{Gem.path.join(',')}'"]
+    t.verbose = true
+  end
+rescue LoadError
+end
+
+require "date"
+
+gem_spec = Gem::Specification.new do |s|
+	s.name   = "unit_record"
+  s.summary = "UnitRecord enables unit testing without hitting the database."
+	s.version = "0.9.0.1"
+	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 = false
+
+  s.autorequire = "unit_record"
+  s.files = FileList['{lib,test,vendor}/**/*.rb', 'CHANGELOG', 'LICENSE', 'README.markdown', 'Rakefile'].to_a
+end
+
+task :gem => %w[test:multi] do
+  Gem::Builder.new(gem_spec).build
+end
+
+namespace :gemspec do
+  desc "generates unit-record.gemspec"
+  task :generate do
+    File.open("unit-record.gemspec", "w") do |f|
+      f.puts "# this file is generated by rake gemspec:generate for github"
+      f.write gem_spec.to_ruby
+    end
+  end
+end
+
+task :readme do
+  require "rubygems"; gem "BlueCloth"; require "BlueCloth"; require 'tmpdir'
+  file = "#{Dir.tmpdir}/readme.html"
+  File.open(file, "w") { |f| f.write BlueCloth.new(File.read("README.markdown")).to_html }
+  sh "open #{file}"
+end
+
+RAILS_VERSIONS = %w[1.2.6 2.0.2 2.1.0 2.1.1 2.2.2 2.3.1]
+
+namespace :test do
+  desc "test with multiple versions of rails"
+  task :multi do
+    RAILS_VERSIONS.each do |rails_version|
+      puts "Testing with Rails #{rails_version}"
+      sh "RAILS_VERSION='#{rails_version}' rake test > /dev/null 2>&1"
+    end
+  end
+  
+  task :multi_verbose do
+    (RAILS_VERSIONS - %w[2.2.2]).each do |rails_version|
+      task = defined?(Rcov) ? "rcov" : "test"
+      sh "RAILS_VERSION='#{rails_version}' rake #{task}"
+    end
+  end
+end
+
+begin
+  gem "rspec"
+  require "spec/rake/spectask"
+  Spec::Rake::SpecTask.new(:spec) do |t|
+    t.spec_files = %w[test/sample_spec.rb]
+  end
+rescue LoadError
+  task :spec do
+    puts "== RSpec failed to load"
+  end
+end
+
+desc "pre-commit task"
+task :pc => %w[test:multi spec gemspec:generate]

data/lib/active_record/connection_adapters/unit_record_adapter.rb

@@ -0,0 +1,97 @@
+class ActiveRecord::ConnectionAdapters::UnitRecordAdapter < ::ActiveRecord::ConnectionAdapters::AbstractAdapter
+  EXCEPTION_MESSAGE = "ActiveRecord is disconnected; database access is unavailable in unit tests."
+
+  def initialize(config = {})
+    super
+    @strategy = config[:strategy] || :raise
+    @cached_columns = {"schema_info" => []}
+  end
+  
+  def columns(table_name, name = nil)#:nodoc:
+    @cached_columns[table_name.to_s] ||
+      raise("Columns are not cached for '#{table_name}' - check schema.rb")
+  end
+
+  def create_table(table_name, options={})
+    table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(self)
+    table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+    yield table_definition
+    @cached_columns[table_name.to_s] =
+      table_definition.columns.map do |c|
+        ActiveRecord::ConnectionAdapters::Column.new(c.name.to_s, c.default, c.sql_type, c.null)
+      end
+  end
+  
+  def native_database_types
+    # Copied from the MysqlAdapter so ColumnDefinition#sql_type will work
+    {
+      :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
+      :string      => { :name => "varchar", :limit => 255 },
+      :text        => { :name => "text" },
+      :integer     => { :name => "int", :limit => 11 },
+      :float       => { :name => "float" },
+      :decimal     => { :name => "decimal" },
+      :datetime    => { :name => "datetime" },
+      :timestamp   => { :name => "datetime" },
+      :time        => { :name => "time" },
+      :date        => { :name => "date" },
+      :binary      => { :name => "blob" },
+      :boolean     => { :name => "tinyint", :limit => 1 }
+    }
+  end
+  
+  def change_strategy(new_strategy, &block)
+    unless [:noop, :raise].include?(new_strategy.to_sym)
+      raise ArgumentError, "#{new_strategy.inspect} is not a valid strategy - valid values are :noop and :raise"
+    end
+    begin
+      old_strategy = @strategy
+      @strategy = new_strategy.to_sym
+      yield
+    ensure
+      @strategy = old_strategy
+    end
+  end
+  
+  def execute(sql, name = nil)
+    raise_or_noop
+  end
+  
+  def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+    raise_or_noop
+  end if Rails::VERSION::MAJOR == 1
+
+  def select_rows(sql, name = nil)
+    raise_or_noop []
+  end
+  
+  def rename_table(table_name, new_name)
+    raise_or_noop
+  end
+  
+  def change_column(table_name, column_name, type, options = {})
+    raise_or_noop
+  end
+  
+  def change_column_default(table_name, column_name, default)
+    raise_or_noop
+  end
+
+  def rename_column(table_name, column_name, new_column_name)
+    raise_or_noop
+  end
+  
+  def tables
+    @cached_columns.keys
+  end
+
+  protected
+  
+  def raise_or_noop(noop_return_value = nil)
+    @strategy == :raise ? raise(EXCEPTION_MESSAGE) : noop_return_value
+  end
+  
+  def select(sql, name = nil)
+    raise_or_noop []
+  end
+end

data/lib/unit_record.rb

@@ -0,0 +1,32 @@
+module UnitRecord
+  def self.rails_version
+    Rails::VERSION::STRING
+  end
+  
+  def self.base_rails_test_class
+    if rails_version >= "2.3.1"
+      ActiveSupport::TestCase
+    else
+      Test::Unit::TestCase
+    end
+  end
+end
+require "unit_record/association_stubbing"
+require "unit_record/column_extension"
+require "unit_record/disconnected_active_record"
+require "unit_record/disconnected_test_case"
+require "unit_record/disconnected_fixtures"
+require "active_record/connection_adapters/unit_record_adapter"
+
+require "active_record/fixtures"
+
+ActiveRecord::ConnectionAdapters::Column.send :include, UnitRecord::ColumnExtension
+ActiveRecord::Base.extend UnitRecord::DisconnectedActiveRecord
+UnitRecord.base_rails_test_class.extend UnitRecord::DisconnectedTestCase
+Fixtures.extend UnitRecord::DisconnectedFixtures
+
+ActiveRecord::Base.class_eval do
+  def self.unit_record_connection(config)
+    ActiveRecord::ConnectionAdapters::UnitRecordAdapter.new(config)
+  end
+end

data/lib/unit_record/association_stubbing.rb

@@ -0,0 +1,39 @@
+module UnitRecord
+  module AssociationStubbing
+    
+    private
+    
+    def initialize_with_association_stubbing(attributes = {})
+      attributes ||= {}
+      associations = extract_associations attributes
+      initialize_without_association_stubbing attributes
+      stub_associations associations
+    end
+    
+    protected
+  
+    def extract_associations(attributes = {})
+      attributes.inject({}) do |associations,(attr,value)|
+        next associations unless self.class.reflections.keys.include? attr
+        unless value.is_a?(self.class.reflections[attr].klass)
+          associations[attr] = attributes.delete attr
+        end
+        associations
+      end
+    end
+  
+    def stub_associations(associations = {})
+      associations.each do |attr,value|
+        self.stubs(attr).returns(value)
+      end
+    end
+
+    def self.included(klass)
+      klass.class_eval do
+        unless (instance_methods + private_instance_methods).include?("initialize_without_association_stubbing")
+          alias_method_chain :initialize, :association_stubbing
+        end
+      end
+    end
+  end
+end