disable_test_fixtures 0.2.0

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2009 Karol Bucek
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,101 @@
+DisableTestFixtures
+===================
+
+Rails plugin that disables fixture loading during test setup.
+Tested with the built-in *Test::Unit* as well as with *MiniTest*.
+
+Unit tests should be fast, active records (unless testing a complicated
+non data dependent business logic) should be connected to a database, but
+every time such a test method runs Rails will make sure Your fixtures are
+correctly loaded (and there's no way turning it off for particular tests).
+
+Until NOW ...
+
+If You don't need fixtures in a test, You might turn them off easily.
+
+NOTE: The plugin assumes transactional fixtures are being used - it can't
+really help with instantiated fixture data !
+
+
+Install
+=======
+
+    gem 'disable_test_fixtures'
+
+or as a plain-old rails plugin :
+
+    script/plugin install git://github.com/kares/disable_test_fixtures.git
+
+
+Example
+=======
+
+    class UserTest < ActiveSupport::TestCase
+      include DisableTestFixtures
+
+      disable_fixtures_for %W{ test_create_a_user }
+
+      test "create a user" do
+        User.create! :name => 'Gregory House'
+        assert_equal 1, User.count
+      end
+
+      # other test methods that use fixtures
+      ...
+
+    end
+
+Of course, You might disable fixtures "globally" for all tests :
+
+    # test_helper.rb
+
+    class ActiveSupport::TestCase
+      include DisableTestFixtures
+
+      disable_fixtures_for :all
+
+      # usual setup :
+      self.use_transactional_fixtures = true
+      self.use_instantiated_fixtures  = false
+      ...
+
+    end
+
+If You have existing test cases that depend on fixtures You might enable the
+fixtures support "back" in the concrete test cases :
+
+    class FixturesDependentTest < ActiveSupport::TestCase
+
+      # assuming fixtures were disabled in test_helper.rb
+
+      enable_fixtures_for :all
+      ...
+
+    end
+
+
+Sample speed improvement running a single test case from a fixture based setup
+with fixtures disabled :
+
+    Finished in 12.705094 seconds.
+
+    49 tests, 200 assertions, 0 failures, 0 errors
+
+
+    Finished in 3.015264 seconds.
+
+    49 tests, 200 assertions, 0 failures, 0 errors
+
+
+Your test will be faster and more readable if You don't use fixtures ...
+Try the factory pattern for creating the data You need in every scenario.
+
+[Test Factory](http://www.dcmanges.com/blog/38)
+
+[Factory Girl](http://github.com/thoughtbot/factory_girl)
+
+NOTE: BE CAREFUL WHEN MIXING TESTS THAT EXPECT AN EMPTY DB WITH TESTS THAT
+DEPEND ON FIXTURES, YOU MIGHT NEED TO MAKE SURE YOUR DB IS CLEAN BEFORE EACH
+AND EVERY CONSECUTIVE RUN (NO FIXTURES LEFT FROM A PREVIOUS TEST FAILURE).
+
+<http://blog.kares.org/search/label/disable_test_fixtures>

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+
+task :default => :test
+
+require 'rake/testtask'
+desc 'Run Unit Tests'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+require 'rdoc/task'
+desc 'Generate Documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DisableTestFixtures'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  #rdoc.rdoc_files.include('README.md')
+  #rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/disable_test_fixtures.rb

@@ -0,0 +1,175 @@
+
+require 'active_support/core_ext/module'
+
+module DisableTestFixtures
+
+  @@last_test_loaded_fixtures = nil
+  mattr_accessor :last_test_loaded_fixtures
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # Disables fixtures for the particular tests in this test case, accepts :
+    #
+    #  String/Symbol - test name
+    #  Array of strings/symbols - test names
+    #  Regexp - matching test names
+    #  Proc - will get test name passed
+    #  :all symbol
+    #
+    # NOTE: fixture disabling is inherited thru the inheritance chain
+    # thus if You've disabled them in super (e.g. ActiveSupport::TestCase)
+    # there's no need to disable them again.
+    def disable_fixtures_for(tests = nil, &block)
+      tests = tests.map { |e| e.to_s } if tests.is_a?(Array)
+      tests = block if tests.nil? && block_given?
+      @fixtures_disabled_tests = tests == :all ? true : tests
+      @fixtures_disabled_tests_negated = false
+      @fixtures_disabled_tests
+    end
+
+    # The opposite of #disable_fixtures_for.
+    # 
+    # NOTE: fixture disabling is inherited thru the inheritance chain
+    # thus if You've disabled them in super (e.g. ActiveSupport::TestCase)
+    # there's no need to disable them again.
+    def enable_fixtures_for(tests = nil, &block)
+      outcome = disable_fixtures_for(tests, &block)
+      @fixtures_disabled_tests_negated = true
+      outcome
+    end
+
+    # #deprecated
+    def disable_fixtures(tests = true)
+      @fixtures_disabled_tests = tests
+    end
+
+    def enable_fixtures
+      @fixtures_disabled_tests = false
+    end
+
+    def fixtures_disabled?(test = nil)
+      fixtures_disabled_tests = @fixtures_disabled_tests
+      #fixtures_disabled_tests = self.instance_variable_get(:@fixtures_disabled_tests)
+      if fixtures_disabled_tests.nil?
+        superclass.respond_to?(:fixtures_disabled?) ?
+          superclass.fixtures_disabled?(test) : false
+      else
+        outcome = case fixtures_disabled_tests
+          when String then
+            test == fixtures_disabled_tests
+          when Symbol then
+            test == fixtures_disabled_tests.to_s
+          when Regexp then
+            !!(test =~ fixtures_disabled_tests)
+          when Array then
+            fixtures_disabled_tests.include?(test)
+          when Proc then
+            fixtures_disabled_tests.arity == 1 ?
+              fixtures_disabled_tests.call(test) :
+                fixtures_disabled_tests.call
+          else !! fixtures_disabled_tests
+        end
+        @fixtures_disabled_tests_negated ? ! outcome : outcome
+      end
+    end
+
+  end
+
+  Fixtures = defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures : Fixtures
+  
+  def fixtures_disabled?
+    self.class.fixtures_disabled?(method_name)
+  end
+
+  def setup_fixtures
+    unless fixtures_disabled?
+      self.last_test_loaded_fixtures = true
+      return super # default (real) setup_fixtures from TestFixtures
+    end
+
+    if last_test_loaded_fixtures?
+      # need to reset all loaded fixtures - empty the tables :
+      unless (loaded_fixtures = already_loaded_fixtures).blank?
+        clear_loaded_fixtures(loaded_fixtures)
+      end
+    end
+
+    self.last_test_loaded_fixtures = false
+    @fixture_cache = {} # fixture helpers should work and return nothing
+    @fixture_connections = [] if enlist = respond_to?(:enlist_fixture_connections)
+
+    # begin transaction :
+    if use_transactional_fixtures? #run_in_transaction?
+      if enlist
+        @fixture_connections = enlist_fixture_connections
+        @fixture_connections.each do |connection|
+          connection.increment_open_transactions
+          connection.transaction_joinable = false
+          connection.begin_db_transaction
+        end
+      else
+        connection = ActiveRecord::Base.connection
+        connection.increment_open_transactions
+        connection.transaction_joinable = false if connection.respond_to?(:transaction_joinable=)
+        connection.begin_db_transaction
+      end
+    else
+      Fixtures.reset_cache # just to be sure ...
+    end
+  end
+
+  private
+
+    # Rails TestFixtures internals !
+    def already_loaded_fixtures
+      begin
+        self.class.send(:class_variable_get, :@@already_loaded_fixtures)
+      rescue NameError # might get here on first run in a single test
+        nil #{ self.class => {} }
+      end
+    end
+
+    # Rails TestFixtures internals !
+    def clear_loaded_fixtures(already_loaded_fixtures)
+      connection = ActiveRecord::Base.connection
+      connection.transaction(:requires_new => true) do
+        already_loaded_fixtures.values.each do |loaded_fixtures|
+          next if loaded_fixtures.nil?
+          loaded_fixtures.each_value do |fixtures|
+            if fixtures.respond_to?(:delete_existing_fixtures)
+              fixtures.delete_existing_fixtures
+            else
+              fixtures.table_rows.keys.each do |table|
+                connection.delete "DELETE FROM #{connection.quote_table_name(table)}", 'Fixture Delete'
+              end
+              
+            end
+          end
+        end
+        # Cap primary key sequences to max(pk).
+        if connection.respond_to?(:reset_pk_sequence!)
+          fixture_table_names.each do |table_name|
+            connection.reset_pk_sequence!(table_name)
+          end
+        end
+      end
+
+      already_loaded_fixtures.clear
+      Fixtures.reset_cache # required to not break when multiple tests are run
+    end
+
+    #
+
+    def last_test_loaded_fixtures?
+      DisableTestFixtures.last_test_loaded_fixtures
+    end
+
+    def last_test_loaded_fixtures=(flag)
+      DisableTestFixtures.last_test_loaded_fixtures = flag
+    end
+
+end

data/test/disable_fixtures_for_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class NonDisabledFixturesTest < ActiveSupport::TestCase
+
+  def test_users
+    assert_equal 1, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 3, Post.count
+  end
+
+  def test_comments
+    assert_equal 5, Comment.all.size
+  end
+
+end
+
+class DisableFixturesForAllTest < ActiveSupport::TestCase
+
+  disable_fixtures_for :all
+
+  def test_users
+    assert_equal 0, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 0, Post.count
+  end
+
+  def test_comments
+    assert_equal 0, Comment.all.size
+  end
+
+  %W{User Post Comment}.each do |model|
+    test "no #{model.downcase}s found" do
+      clazz = Object.const_get(model.to_sym)
+      all_instances = clazz.find :all
+      #assert_equal Array, all_instances.class
+      assert_equal 0, all_instances.size
+    end
+  end
+
+end
+
+class DisableFixturesForRegexpTest < ActiveSupport::TestCase
+
+  disable_fixtures_for /users/
+
+  def test_users
+    assert_equal 0, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 3, Post.count
+  end
+
+  def test_comments
+    assert_equal 5, Comment.all.size
+  end
+
+  test "no users found" do
+    all_instances = User.find :all
+    #assert_equal Array, all_instances.class
+    assert_equal 0, all_instances.size
+  end
+
+end
+
+class DisableFixturesForArrayOfNamesTest < ActiveSupport::TestCase
+
+  disable_fixtures_for %W{test_posts test_comments}
+
+  def test_users
+    assert_equal 1, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 0, Post.count
+  end
+
+  def test_comments
+    assert_equal 0, Comment.all.size
+  end
+
+end
+
+class DisableFixturesForProcTest < ActiveSupport::TestCase
+
+  disable_fixtures_for do |test_name|
+    test_name == 'test_comments'
+  end
+
+  def setup
+    super
+  end
+
+  def test_users
+    assert_equal 1, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 3, Post.count
+  end
+
+  def test_comments
+    assert_equal 0, Comment.all.size
+  end
+
+end

data/test/disable_test_fixtures_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+require 'disable_test_fixtures'
+
+class DisableTestFixturesTest < Test::Unit::TestCase
+
+  class TheTest
+    include DisableTestFixtures
+  end
+
+  def test_responds_to_disable_fixtures_for?
+    assert TheTest.respond_to? :disable_fixtures_for
+  end
+
+  def test_responds_to_enable_fixtures_for?
+    assert TheTest.respond_to? :enable_fixtures_for
+  end
+
+  class DisableAllTest
+    include DisableTestFixtures
+    disable_fixtures_for :all
+  end
+
+  def test_disable_all_fixtures_disabled?
+    assert DisableAllTest.fixtures_disabled?('test_method')
+  end
+
+  class EnableAllTest
+    include DisableTestFixtures
+    enable_fixtures_for :all
+  end
+
+  def test_enable_all_fixtures_disabled?
+    assert ! EnableAllTest.fixtures_disabled?('test_method')
+  end
+
+  class DisableAllInheritedTest < DisableAllTest; end
+
+  def test_inherited_disable_all_fixtures_disabled?
+    assert DisableAllInheritedTest.fixtures_disabled?('test_method')
+  end
+
+  class EnableAllInheritedTest < EnableAllTest; end
+
+  def test_inherited_enable_all_fixtures_disabled?
+    assert ! EnableAllInheritedTest.fixtures_disabled?('test_method')
+  end
+
+  class DisableEqualTest
+    include DisableTestFixtures
+    disable_fixtures_for [ 'test_method' ]
+  end
+
+  def test_disable_equal_fixtures_disabled?
+    assert DisableEqualTest.fixtures_disabled?('test_method')
+    assert ! DisableEqualTest.fixtures_disabled?('test_other_method')
+  end
+
+  class DisableMatchTest
+    include DisableTestFixtures
+    disable_fixtures_for /test_method/
+  end
+
+  def test_disable_match_fixtures_disabled?
+    assert DisableMatchTest.fixtures_disabled?('test_method')
+    assert DisableMatchTest.fixtures_disabled?('test_method_another')
+    assert ! DisableMatchTest.fixtures_disabled?('test_other_method')
+  end
+
+  class EnableEqualTest
+    include DisableTestFixtures
+    enable_fixtures_for [ 'test_method' ]
+  end
+
+  def test_disable_equal_fixtures_disabled?
+    assert ! EnableEqualTest.fixtures_disabled?('test_method')
+    assert EnableEqualTest.fixtures_disabled?('test_other_method')
+  end
+
+end

data/test/enable_fixtures_for_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class EnableFixturesForRegexpTest < ActiveSupport::TestCase
+
+  enable_fixtures_for /posts|comments/
+
+  def test_users
+    assert_equal 0, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 3, Post.count
+  end
+
+  def test_comments
+    assert_equal 5, Comment.all.size
+  end
+
+  test "no users found" do
+    all_instances = User.find :all
+    #assert_equal Array, all_instances.class
+    assert_equal 0, all_instances.size
+  end
+
+end
+
+class EnableFixturesForArrayOfNamesTest < ActiveSupport::TestCase
+
+  enable_fixtures_for %W{ test_users }
+
+  def test_users
+    assert_equal 1, User.find_all_by_email('ferko@suska.net').size
+  end
+
+  def test_posts
+    assert_equal 0, Post.count
+  end
+
+  def test_comments
+    assert_equal 0, Comment.all.size
+  end
+
+end

data/test/mini_test_helper.rb

@@ -0,0 +1,52 @@
+
+require 'rbconfig'
+
+module MiniTestHelper
+
+  def self.enable_miniunit
+    File.symlink File.join(minidir, "minitest"), File.join(sitelib, "minitest")
+    File.symlink File.join(minidir, "test"), File.join(sitelib, "test")
+    puts "enabled miniunit - added links to #{sitelib}"
+  end
+
+  def self.disable_miniunit
+    File.unlink File.join(sitelib, "minitest")
+    File.unlink File.join(sitelib, "test")
+    puts "disabled miniunit - removed links from #{sitelib}"
+  end
+
+  private
+
+  def self.minidir
+    File.join(projdir, "lib")
+  end
+
+  def self.projdir
+    use_minitest_path = Gem.bin_path('minitest_tu_shim', 'use_minitest')
+    File.dirname(File.dirname(File.expand_path( use_minitest_path )))
+  end
+
+  def self.sitelib
+    Config::CONFIG["sitelibdir"]
+  end
+
+end
+
+require 'rubygems'
+
+# NOTE: assuming testing on Ruby 1.8 !
+#
+# http://blog.floehopper.org/articles/2009/02/02/test-unit-and-minitest-with-different-ruby-versions
+#
+# sudo chmod a+rw /usr/local/lib/site_ruby/1.8 (sitelibdir)
+#
+def execute_with_minitest
+  raise 'no block given' unless block_given?
+  begin
+    MiniTestHelper.enable_miniunit
+    require 'test_helper'
+    yield
+  ensure
+    MiniTestHelper.disable_miniunit
+  end
+end

data/test/mini_test_run.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+require 'mini_test_helper'
+
+# run all tests with mini_test :
+tests = Dir.glob('*_test.rb')
+execute_with_minitest do
+  tests.each { |test| load test }
+end

data/test/rails_setup.rb

@@ -0,0 +1,104 @@
+# enable testing with different version of rails via argv :
+# ruby request_exception_handler_test.rb RAILS_VERSION=2.2.2
+
+version =
+  if ARGV.find { |opt| /RAILS_VERSION=([\d\.]+)/ =~ opt }
+    $~[1] # rake test RAILS_VERSION=2.3.10
+  else
+    ENV['RAILS_VERSION']
+  end
+
+if version
+  RAILS_VERSION = version
+  gem 'activesupport', "= #{RAILS_VERSION}"
+  gem 'activerecord', "= #{RAILS_VERSION}"
+  gem 'rails', "= #{RAILS_VERSION}"
+else
+  gem 'activesupport'
+  gem 'activerecord'
+  gem 'rails'
+end
+
+require 'rails/version'
+puts "emulating Rails.version = #{version = Rails::VERSION::STRING}"
+
+require 'active_support'
+require 'active_support/test_case'
+if version >= '3.0.0'
+  # otherwise require 'active_record/fixtures' fails in 3.0.0 !
+  require 'active_support/core_ext/class/delegating_attributes'
+end
+
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_record/test_case'
+
+# Make double-sure the RAILS_ENV is set to test,
+# so fixtures are loaded to the right database
+silence_warnings { RAILS_ENV = "test" }
+silence_warnings { RAILS_ROOT = File.dirname(__FILE__) }
+
+module Rails
+  class << self
+
+    def initialized?
+      @initialized || false
+    end
+
+    def initialized=(initialized)
+      @initialized ||= initialized
+    end
+
+    def logger
+      if defined?(RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER
+      else
+        nil
+      end
+    end
+
+    def backtrace_cleaner
+      @@backtrace_cleaner ||= begin
+        #require 'rails/gem_dependency' # backtrace_cleaner depends on this !
+        #require 'rails/backtrace_cleaner'
+        #Rails::BacktraceCleaner.new
+        require 'active_support/backtrace_cleaner'
+        ActiveSupport::BacktraceCleaner.new
+      end
+    end
+
+    def root
+      Pathname.new(RAILS_ROOT) if defined?(RAILS_ROOT)
+    end
+
+    def env
+      @_env ||= ActiveSupport::StringInquirer.new(RAILS_ENV)
+    end
+
+    def version
+      VERSION::STRING
+    end
+
+    def public_path
+      @@public_path ||= self.root ? File.join(self.root, "public") : "public"
+    end
+
+    def public_path=(path)
+      @@public_path = path
+    end
+  end
+end
+
+class ActiveSupport::TestCase
+  # only if defined e.g. Rails 2.2.3 monkey patches Test::Unit::TestCase :
+  include ActiveRecord::TestFixtures if defined? ActiveRecord::TestFixtures
+
+  #self.fixture_path = "#{RAILS_ROOT}/test/fixtures/"
+  #self.use_instantiated_fixtures  = false
+  #self.use_transactional_fixtures = true
+  
+end
+
+def create_fixtures(*table_names, &block)
+  Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+end

data/test/test_helper.rb

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'test/unit'
+
+DATA_DIR = File.join(File.dirname(__FILE__), 'data')
+FIXTURES_ROOT = File.join(DATA_DIR, 'fixtures')
+
+require File.join(File.dirname(__FILE__), 'rails_setup')
+
+ActiveRecord::Migration.verbose = false # quiet down the migration engine
+
+db =
+  if ARGV.find { |opt| /DB=([\d\.]+)/ =~ opt }
+    $~[1] # rake test DB=mysql
+  else
+    ENV['DB']
+  end || 'sqlite3'
+
+load File.join(File.dirname(__FILE__), 'db', "#{db}_config.rb")
+
+ActiveRecord::Base.establish_connection('test')
+ActiveRecord::Base.silence do
+  load File.join(DATA_DIR, 'schema.rb')
+end
+
+require File.join(File.dirname(__FILE__), 'data/models')
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+require 'disable_test_fixtures'
+
+Fixtures = ActiveRecord::Fixtures unless defined?(Fixtures) # used in .ymls
+
+class ActiveSupport::TestCase
+
+  include DisableTestFixtures
+
+  self.fixture_path = FIXTURES_ROOT
+
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # The only drawback to using transactional fixtures is when you actually
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+end

data/test/user_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class UserTest < ActiveSupport::TestCase
+
+  disable_fixtures_for :all
+
+  def test_users_1
+    User.create! :name => 'User 1', :email => 'user1@test.me'
+
+    assert_equal 1, User.all.size
+  end
+
+  def test_users_2
+    User.create! :name => 'User 1', :email => 'user1@test.me'
+    User.create! :name => 'User 2', :email => 'user2@test.me'
+
+    assert_equal 2, User.count
+  end
+
+  def test_users_3
+    User.create! :name => 'User 1', :email => 'user1@test.me'
+    User.create! :name => 'User 2', :email => 'user2@test.me'
+    User.create! :name => 'User 3', :email => 'user3@test.me'
+
+    assert_not_nil User.first
+    assert_not_equal User.first, User.last
+
+    assert_equal 3, User.count
+  end
+
+  def test_users_0
+    assert_equal [], User.find(:all)
+  end
+
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: disable_test_fixtures
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Karol Bucek
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Unit tests should be fast, active records (unless testing a complicated non data dependent business logic) should be connected to a database, but every time such a test method runs Rails will make sure Your fixtures are correctly loaded (and there's no way turning it off for particular tests).
+email: 
+- self@kares.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/disable_test_fixtures.rb
+- LICENSE
+- README.md
+- Rakefile
+- test/disable_test_fixtures_test.rb
+- test/user_test.rb
+- test/mini_test_run.rb
+- test/mini_test_helper.rb
+- test/enable_fixtures_for_test.rb
+- test/test_helper.rb
+- test/disable_fixtures_for_test.rb
+- test/rails_setup.rb
+homepage: http://github.com/kares/disable_test_fixtures
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Rails plugin that disables fixture loading during test setup.
+test_files: 
+- test/disable_test_fixtures_test.rb
+- test/user_test.rb
+- test/mini_test_run.rb
+- test/mini_test_helper.rb
+- test/enable_fixtures_for_test.rb
+- test/test_helper.rb
+- test/disable_fixtures_for_test.rb
+- test/rails_setup.rb