factory_data_preloader 0.5.2

data/CHANGELOG.rdoc

@@ -0,0 +1,49 @@
+== 0.5.2 / 2009-07-09
+
+* Improved backtrace output.
+
+== 0.5.1 / 2009-07-07
+
+* Fixed a couple of bugs that caused the data to be preloaded multiple times or deleted multiple times.
+
+== 0.5.0 / 2009-07-07
+
+* Added better error handling.  The data[:key] = record form is deprecated in favor of data.add(:key) { record }.
+* Allow preloaders to be redefined.  This should make this more compatible with autotest.
+
+== 0.4.3 / 2009-06-05
+
+* Added shoulda and mocha development dependencies.
+
+== 0.4.2 / 2009-06-02
+
+* Raise an appropriate error when the developer tries to get a record for a preloader that was never run.
+
+== 0.4.1 / 2009-06-01
+
+* Updated documentation (Forgot to for the 0.4.0 release).
+
+== 0.4.0 / 2009-06-01
+
+* Added ability to only preload some of the types.
+* During preloading, print to the console to indicate the records being preloaded and a benchmark.
+
+== 0.3.2 / 2009-04-07
+
+* Fixed a bug with the ordering of the dependent preloaders.
+
+== 0.3.1 / 2009-03-30
+
+* Updated documentation. (Forgot to for 0.3.0 release)
+
+== 0.3.0 / 2009-03-30
+
+* Added logic to auto load the factory_data files.
+
+== 0.2.0 / 2009-03-30
+
+* Added :depends_on option to the preloader, to force the preloaders to load in the correct order based on your foreign keys and table dependencies.
+
+== 0.1.0 / 2009-03-30
+
+* Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Myron Marston, Kashless.org
+
+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.rdoc

@@ -0,0 +1,132 @@
+= factory_data_preloader
+
+If you're like me, you really dislike using rails test fixtures.  On the rails projects I've worked on that
+have used test fixtures, we've had a number of tests that passed as false positives because the test
+fixtures don't represent "real data".  Fixtures just dump the data you've defined directly into the database,
+without going through the model--meaning you don't get any of the validations or before/after save callback 
+behavior defined on your models.
+
+There are multiple gems and plugins that address this; my personal favorite is {factory girl}[http://github.com/thoughtbot/factory_girl/].
+
+However, none of the solutions I've tried are as fast as using test fixtures.  When you use test fixtures,
+rails rolls back the database transaction used in each test and allows you to re-use your fixture data.  
+This is much much quicker then creating the data you will use directly in each test.
+
+This gem attempts to solve this issue, and give you the best of both worlds: create your test data using 
+factory girl, the models themselves, or any other solution you want, while also being able to pre-load it
+and re-use it in each test when rails rolls back the transaction.
+
+== Download
+
+Github: http://github.com/myronmarston/factory_data_preloader/tree/master
+
+Gem:
+  gem install myronmarston-factory_data_preloader --source http://gems.github.com
+  
+== Usage
+
+Load the gem using Rails' 2.1+ gem support, in either config/environment.rb, or config/environments/test.rb:
+  config.gem 'myronmarston-factory_data_preloader', 
+    :lib => 'factory_data_preloader', 
+    :source => 'http://gems.github.com'
+
+Define your preloaded data.  FactoryData will automatically require test/factory_data.rb or test/factory_data/*.rb.
+Define your data in these files like this:
+
+  FactoryData.preload(:users) do |data|
+    data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+    data.add(:john) { User.create(:first_name => 'John', :last_name => 'Doe') }
+  end
+
+  FactoryData.preload(:posts, :depends_on => :users) do |data|
+    # note the use of the :depends_on option to force the users to be loaded first.
+    data.add(:tour) { FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.') }
+  end
+  
+  FactoryData.preload(:some_other_posts, :model_class => Post, :depends_on => :users) do |data|
+    # note the use of the :model_class option when the model class cannot be inferred from the symbol.
+    data.add(:another_post) { Post.create(:user => FactoryData.users(:john), :title => 'Life is good') }
+  end
+
+  FactoryData.preload(:comments, :depends_on => [:users, :posts]) do |data|
+    # :depends_on lets you pass an array
+    data.add(:woohoo) { FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!") }
+  end
+
+Finally, use this preloaded data in your tests:
+
+  # test/user_test.rb
+  class UserTest < ActiveSupport::TestCase
+    def test_thom_has_last_name
+      user = FactoryData.users(:thom)
+      assert_equal 'York', user.last_name
+    end
+  end
+
+  # test/post_test.rb
+  class PostTest < ActiveSupport::TestCase
+    def test_post_has_body
+      post = FactoryData.posts(:tour)
+      assert_not_nil post.body
+    end
+  end
+
+All factory data is automatically preloaded for all tests.  In a large rails application, this can incur a significant performance penalty 
+at the start of each test run.  If you want finer grain control over which preloaders run, you can configure it like so:
+
+  # in test_helper.rb
+  FactoryDataPreloader.preload_all = false
+
+  # test/user_test.rb
+  class UserTest < ActiveSupport::TestCase
+    preload_factory_data :users # multiple types can be listed as necessary
+    # tests go here...
+  end
+
+  # test/post_test.rb
+  class PostTest < ActiveSupport::TestCase
+    preload_factory_data :posts # dependencies are taken into account, so users will automatically be preloaded as well.
+    # tests go here...
+  end
+
+== Notes, etc.
+
+* This gem has been tested with Rails 2.2.2 and Rails 2.3.2.
+* You can create the data using any fixture replacement you want.  In this contrived example, I just used ActiveRecord's
+  built in methods for simplicity's sake.
+* FactoryData#preload does not actually preload the data.  It simply defines the data that will be automatically preloaded
+  at the appropriate time (namely, at the same time when rails loads the fixtures).
+* FactoryData#preload defines a new method on FactoryData using the same name as the symbol.
+* This can be mixed-n-matched with fixtures.  You may want to keep using fixtures in an existing code base,
+  or migrate over to this slowly.
+* If you have dependencies between your preloaded data, you can use the :depends_on option to force some records to be preloaded 
+  before others.  Where no dependencies exist, the preloaders are run in the order they are defined.
+* FactoryData#preload attempts to infer the appropriate model class from the symbol you pass.  If your symbol doesn't
+  match the model class, pass the model class using the :model_class option.
+* The preloader will also delete all records from the database, before any preloading begins.  This is done at the same
+  time that rails deletes records for test fixtures.  The tables are cleared using the reverse of the order defined by 
+  your :depends_on options, so be sure to use :depends_on if you have foreign key constraints.
+* Errors that occur during preloading are handled smartly: a warning is printed when one occurs, and an exception is raised
+  when the record that had the error is accessed.  This should allow the rest of the data to be preloaded, and cause only
+  the tests that access the records with errors to fail.
+* The syntax used before the 0.5.0 release is still allowed but has been deprecated.  Instead of this:
+
+    FactoryData.preload(:users) do |data|
+      data[:thom] = User.create(:first_name => 'Thom', :last_name => 'York')
+      data[:john] = User.create(:first_name => 'John', :last_name => 'Doe')
+    end
+
+Use this:
+
+    FactoryData.preload(:users) do |data|
+      data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+      data.add(:john) { User.create(:first_name => 'John', :last_name => 'Doe') }
+    end
+
+== Known Issues
+
+* This gem doesn't play nice with autotest.
+
+== Copyright
+
+Copyright (c) 2009 Myron Marston, Kashless.org. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 5
+:patch: 2

data/lib/factory_data_preloader.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'rubygems'
+
+if ENV['RAILS_VERSION']
+  puts "loading Rails version #{ENV['RAILS_VERSION']}"
+  gem "activesupport", "= #{ENV['RAILS_VERSION']}"
+  gem "activerecord", "= #{ENV['RAILS_VERSION']}"
+end
+
+require 'active_support'
+require 'active_record'
+require 'active_record/fixtures'
+
+require 'factory_data_preloader/core_ext'
+require 'factory_data_preloader/preloader'
+require 'factory_data_preloader/preloader_collection'
+require 'factory_data_preloader/preloaded_data_hash'
+require 'factory_data_preloader/factory_data'
+require 'factory_data_preloader/rails_core_ext'
+
+if defined? Rails.configuration
+  Rails.configuration.after_initialize do
+    FactoryData.definition_file_paths = [
+      File.join(RAILS_ROOT, 'test', 'factory_data'),
+      File.join(RAILS_ROOT, 'spec', 'factory_data')
+    ]
+    FactoryData.find_definitions
+  end
+else
+  FactoryData.find_definitions
+end

data/lib/factory_data_preloader/core_ext.rb

@@ -0,0 +1,23 @@
+# http://github.com/rails/rails/tree/823b623fe2de8846c37aa13250010809ac940b57/activesupport/lib/active_support/core_ext/object/misc.rb
+
+unless Object.respond_to?(:try) # Object#try is in Rails 2.3 but not in 2.2.
+  class Object
+    # Tries to send the method only if object responds to it. Return +nil+ otherwise.
+    # It will also forward any arguments and/or block like Object#send does.
+    # 
+    # ==== Example :
+    # 
+    # # Without try
+    # @person ? @person.name : nil
+    # 
+    # With try
+    # @person.try(:name)
+    #
+    # # try also accepts arguments/blocks for the method it is trying
+    # Person.try(:find, 1)
+    # @people.try(:map) {|p| p.name}
+    def try(method, *args, &block)
+      send(method, *args, &block) if respond_to?(method, true)
+    end
+  end
+end

data/lib/factory_data_preloader/factory_data.rb

@@ -0,0 +1,81 @@
+require 'ostruct'
+
+module FactoryDataPreloader
+  class PreloaderAlreadyDefinedError < StandardError; end
+  class PreloadedRecordNotFound < StandardError; end
+  class DefinedPreloaderNotRunError < StandardError; end
+  class ErrorWhilePreloadingRecord < StandardError; end
+
+  module DataMethods
+  end
+
+  class FactoryData
+    @@single_test_cache = {}
+
+    extend DataMethods
+
+    class << self
+      # An Array of strings specifying locations that should be searched for
+      # factory_data definitions. By default, factory_data_preloader will attempt to require
+      # "factory_data," "test/factory_data," and "spec/factory_data." Only the first
+      # existing file will be loaded.
+      attr_accessor :definition_file_paths
+
+      def preload(model_type, options = {}, &proc)
+        if existing_preloader = AllPreloaders.instance.from_symbol(model_type, false)
+          existing_preloader.remove!
+        end
+
+        FactoryDataPreloader::Preloader.new(model_type, options[:model_class], proc, options[:depends_on])
+
+        DataMethods.class_eval do
+          define_method model_type do |key|
+            FactoryData.send(:get_record, model_type, key)
+          end
+        end
+      end
+
+      def delete_preload_data!
+        # Delete them in the reverse order of the dependencies, to handle foreign keys
+        FactoryDataPreloader.requested_preloaders.dependency_order.reverse.each do |preloader|
+          preloader.delete_table_data!
+        end
+      end
+
+      def preload_data!
+        FactoryDataPreloader.requested_preloaders.dependency_order.each do |preloader|
+          preloader.preload!
+        end
+      end
+
+      def reset_cache!
+        @@single_test_cache = {}
+      end
+
+      def find_definitions
+        definition_file_paths.each do |path|
+          require("#{path}.rb") if File.exists?("#{path}.rb")
+
+          if File.directory? path
+            Dir[File.join(path, '*.rb')].each do |file|
+              require file
+            end
+          end
+        end
+      end
+
+      private
+
+      def get_record(type, key)
+        preloader = AllPreloaders.instance.from_symbol(type)
+        @@single_test_cache[type]      ||= {}
+        @@single_test_cache[type][key] ||= preloader.get_record(key)
+      end
+    end
+
+    self.definition_file_paths = %w(factory_data test/factory_data spec/factory_data)
+  end
+end
+
+# alias this class so that apps that use it don't have to use the fully qualified name.
+FactoryData = FactoryDataPreloader::FactoryData

data/lib/factory_data_preloader/preloaded_data_hash.rb

@@ -0,0 +1,53 @@
+class PreloadedDataHash
+  attr_reader :preloader
+
+  def initialize(preloader)
+    @preloader, @backing_hash = preloader, {}
+  end
+
+  def []=(key, record)
+    puts "DEPRECATION WARNING: Instead of 'data[:#{key}] = record' please use 'data.add(:#{key}) { record }'"
+    add_to_backing_hash(key, record)
+  end
+
+  def [](key)
+    @backing_hash[key]
+  end
+
+  def record_ids
+    @backing_hash.values.select { |value| value.is_a?(Fixnum) }
+  end
+
+  def add(key)
+    raise "You must pass a block to PreloaderDataHash#add.  You forgot to use the block in your #{preloader.model_type} prelodaer for the #{key.inspect} record." unless block_given?
+    begin
+      add_to_backing_hash(key, yield)
+    rescue => e
+      puts "WARNING: an error occurred while preloading the #{preloader.model_type.to_s}(:#{key}) record: #{e.class.to_s}: #{e.message}"
+      add_to_backing_hash(key, nil, e)
+    end
+  end
+
+  private
+
+  def add_to_backing_hash(key, record, error = nil)
+    print '.'
+    if record
+      if record.new_record? && !record.save
+        raise StandardError.new("Error preloading factory data.  #{preloader.model_class.to_s} :#{key.to_s} could not be saved.  Errors: #{pretty_error_messages(record)}")
+      else
+        @backing_hash[key] = record.id
+      end
+    else
+      @backing_hash[key] = error
+    end
+  end
+
+  # Borrowed from shoulda: http://github.com/thoughtbot/shoulda/blob/e02228d45a879ff92cb72b84f5fccc6a5f856a65/lib/shoulda/active_record/helpers.rb#L4-9
+  def pretty_error_messages(obj)
+    obj.errors.map do |a, m|
+      msg = "#{a} #{m}"
+      msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+    end
+  end
+end

data/lib/factory_data_preloader/preloader.rb

@@ -0,0 +1,102 @@
+require 'active_support/deprecation'
+
+module FactoryDataPreloader
+  class PreloaderNotDefinedError < StandardError; end
+
+  mattr_accessor :preload_all
+  self.preload_all = true
+
+  mattr_accessor :preload_types
+  self.preload_types = []
+
+  class << self
+    alias :preload_all? :preload_all
+
+    def requested_preloaders
+      if preload_all?
+        AllPreloaders.instance
+      else
+        preloaders = self.preload_types.collect { |type| AllPreloaders.instance.from_symbol(type) }
+        preloaders += (preloaders.collect { |p| p.all_dependencies }).flatten
+        preloaders.uniq!
+        PreloaderCollection.new(preloaders)
+      end
+    end
+  end
+
+  class Preloader
+    attr_accessor :model_type, :model_class, :proc, :depends_on
+    attr_reader   :data
+
+    def initialize(model_type, model_class, proc, depends_on)
+      model_class ||= model_type.to_s.pluralize.classify.constantize
+
+      @model_type, @model_class, @proc, @depends_on = model_type, model_class, proc, [depends_on].compact.flatten
+      AllPreloaders.instance << self
+
+      DataMethods.class_eval do
+        define_method model_type do |key|
+          FactoryData.send(:get_record, model_type, key)
+        end
+      end
+    end
+
+    def preload!
+      return if preloaded?
+      @data = PreloadedDataHash.new(self)
+      print "Preloading #{model_type}:"
+      benchmark_measurement = Benchmark.measure { self.proc.try(:call, @data) }
+      print "(#{format('%.3f', benchmark_measurement.real)} secs)\n"
+    end
+
+    def preloaded?
+      !@data.nil?
+    end
+
+    def delete_table_data!
+      unless @table_data_deleted
+        self.model_class.delete_all
+        @table_data_deleted = true
+      end
+    end
+
+    def dependencies
+      self.depends_on.collect { |dependency| AllPreloaders.instance.from_symbol(dependency) }
+    end
+
+    def all_dependencies
+      (self.dependencies + (self.dependencies.collect { |d| d.all_dependencies }).flatten).uniq
+    end
+
+    def get_record(key)
+      unless self.preloaded?
+        raise DefinedPreloaderNotRunError.new, "The :#{self.model_type} preloader has never been run.  Did you forget to add the 'preload_factory_data :#{self.model_type}' declaration to your test case?  You'll need this at the top of your test case class if you want to use the factory data defined by this preloader."
+      end
+
+      unless record_id_or_error = self.data[key]
+        raise PreloadedRecordNotFound.new, "Could not find a preloaded record #{self.model_type} record for :#{key}.  Did you mispell :#{key}?"
+      end
+
+      if record_id_or_error.is_a?(Exception)
+        raise ErrorWhilePreloadingRecord.new, "An error occurred while preloading #{self.model_type}(:#{key}): #{record_id_or_error.class.to_s}: #{record_id_or_error.message}\n\nBacktrace:\n\n    #{record_id_or_error.backtrace.join("\n    ")}\n"
+      end
+
+      self.model_class.find_by_id(record_id_or_error)
+    end
+
+    def remove!
+      preloader = self
+      DataMethods.class_eval do
+        remove_method(preloader.model_type) if method_defined?(preloader.model_type)
+      end
+
+      if @data
+        self.model_class.delete_all(:id => @data.record_ids)
+        @data = nil
+      end
+
+      AllPreloaders.instance.delete(self)
+    end
+  end
+
+end

data/lib/factory_data_preloader/preloader_collection.rb

@@ -0,0 +1,30 @@
+module FactoryDataPreloader
+  class PreloaderCollection < Array
+    def dependency_order
+      unordered_preloaders = Array.new(self) # rather than using self.dup since singleton doesn't allow duping.
+      ordered_preloaders = []
+
+      until unordered_preloaders.empty?
+        unordered_preloaders.each do |preloader|
+          if preloader.dependencies.all? { |dependency| ordered_preloaders.include?(dependency) }
+            ordered_preloaders << unordered_preloaders.delete(preloader)
+          end
+        end
+      end
+
+      ordered_preloaders
+    end
+
+    def from_symbol(symbol, raise_error = true)
+      unless preloader = self.detect { |p| p.model_type == symbol }
+        raise PreloaderNotDefinedError, "The preloader for :#{symbol} has not been defined." if raise_error
+      end
+      preloader
+    end
+  end
+
+  class AllPreloaders < PreloaderCollection
+    include Singleton
+  end
+
+end

data/lib/factory_data_preloader/rails_core_ext.rb

@@ -0,0 +1,39 @@
+# TODO: add tests for this.  I've manually tested this in a Rails 2.2 and 2.3 app, but haven't found a way to add
+# a test for this to our test suite.  It's difficult to test this since it just modifies what happens before the 
+# tests are run.
+
+# Between Rails 2.2 and 2.3, the fixture loading code was moved from
+# Test::Unit::TestCase to ActiveRecord::TestFixtures.  See this commit:
+# http://github.com/rails/rails/commit/b0ee1bdf2650d7a8380d4e9be58bba8d9c5bd40e
+patch_module = defined?(ActiveRecord::TestFixtures) ? ActiveRecord::TestFixtures : Test::Unit::TestCase
+
+patch_module.class_eval do
+  def load_fixtures_with_preloaded_factory_data
+    val = load_fixtures_without_preloaded_factory_data
+    FactoryData.preload_data!
+    val
+  end
+    
+  def teardown_fixtures_with_preloaded_factory_data
+    FactoryData.reset_cache!
+    teardown_fixtures_without_preloaded_factory_data
+  end
+
+  alias_method_chain :load_fixtures, :preloaded_factory_data
+  alias_method_chain :teardown_fixtures, :preloaded_factory_data
+end
+
+class Fixtures
+  def delete_existing_fixtures_with_preloaded_factory_data
+    delete_existing_fixtures_without_preloaded_factory_data
+    FactoryData.delete_preload_data!
+  end
+  
+  alias_method_chain :delete_existing_fixtures, :preloaded_factory_data
+end
+
+class ActiveSupport::TestCase
+  def self.preload_factory_data(*types)
+    types.each { |t| FactoryDataPreloader.preload_types << t }
+  end
+end

data/test/factory_data_test.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FactoryDataTest < Test::Unit::TestCase
+  def setup
+    FactoryDataPreloader.reset!
+  end
+
+  context 'Calling FactoryData.preload(:users)' do
+    setup do
+      FactoryData.preload(:users) do |data|
+        data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+      end
+    end
+
+    should_not_change 'User.count'
+    should_change "FactoryData.methods.include?('users')", :from => false, :to => true
+
+    context 'when there was a previous user record in the database' do
+      setup { User.create(:first_name => 'Barack', :last_name => 'Obama') }
+
+      context 'and calling FactoryData.delete_preload_data!' do
+        setup { FactoryData.delete_preload_data! }
+        should_change 'User.count', :to => 0
+      end
+    end
+
+    context 'and later calling FactoryData.preload_data!' do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          FactoryData.preload_data!
+        end
+      end
+
+      should_change 'User.count', :by => 1
+
+      context 'and later re-defining the preloaders' do
+        setup do
+          FactoryData.preload(:users) do |data|
+            data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+            data.add(:john) { User.create(:first_name => 'John', :last_name => 'Doe') }
+          end
+        end
+
+        should_change 'User.count', :by => -1
+
+        context 'and preloading the re-defined preloader' do
+          setup do
+            @out, @err = OutputCapturer.capture do
+              FactoryData.preload_data!
+            end
+          end
+
+          should_change 'User.count', :by => 2
+        end
+      end
+
+      context 'and later calling FactoryData.users(key)' do
+        setup { @user = FactoryData.users(:thom) }
+
+        should 'retrieve the correct user' do
+          assert_equal 'Thom', @user.first_name
+          assert_equal 'York', @user.last_name
+          assert !@user.new_record?
+        end
+
+        should 'raise the appropriate error for a non-existant key' do
+          assert_raise FactoryDataPreloader::PreloadedRecordNotFound do
+            FactoryData.users(:not_a_user)
+          end
+        end
+
+        should 'cache the record so as not to use User.find more than necessary' do
+          User.expects(:find).never
+          user2 = FactoryData.users(:thom)
+          assert_equal @user.object_id, user2.object_id
+        end
+
+        context 'and later calling FactoryData.reset_cache!' do
+          setup { FactoryData.reset_cache! }
+
+          should 'reload the record from the database the next time FactoryData.users(key) is called' do
+            User.expects(:find).once.returns(@user)
+            FactoryData.users(:thom)
+          end
+        end
+      end
+    end
+  end
+
+  context 'Preloading with an explicit :model_class option' do
+    setup do
+      FactoryData.preload(:posts, :model_class => User) do |data|
+        data.add(:george) { User.create(:first_name => 'George', :last_name => 'Washington') }
+      end
+      @out, @err = OutputCapturer.capture do
+        FactoryData.preload_data!
+      end
+    end
+
+    should 'use the passed model_class rather than inferring the class from the symbol' do
+      assert_equal User, FactoryData.posts(:george).class
+    end
+  end
+
+  context 'Preloading multiple record types, with dependencies' do
+    setup do
+      FactoryData.preload(:comments, :depends_on => [:users, :posts]) do |data|
+        data.add(:woohoo) { FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!") }
+      end
+
+      FactoryData.preload(:posts, :depends_on => :users) do |data|
+        data.add(:tour) { FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.') }
+      end
+
+      FactoryData.preload(:users) do |data|
+        data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+        data.add(:john) { User.create(:first_name => 'John', :last_name => 'Doe') }
+      end
+    end
+
+    should "raise the appropriate error when a developer tries to access a record that wasn't preloaded" do
+      FactoryDataPreloader.preload_all = false
+      FactoryDataPreloader.preload_types << :users
+
+      @out, @err = OutputCapturer.capture do
+        FactoryData.preload_data!
+      end
+
+      assert FactoryData.users(:thom)
+      assert_raise FactoryDataPreloader::DefinedPreloaderNotRunError do
+        FactoryData.posts(:tour)
+      end
+    end
+
+    should 'preload them in the proper order, allowing you to use the dependencies' do
+      @out, @err = OutputCapturer.capture do
+        FactoryData.preload_data!
+      end
+
+      assert_equal 'Thom', FactoryData.users(:thom).first_name
+      assert_equal 'John', FactoryData.users(:john).first_name
+
+      assert_equal FactoryData.users(:thom), FactoryData.posts(:tour).user
+
+      assert_equal FactoryData.users(:john), FactoryData.comments(:woohoo).user
+      assert_equal FactoryData.posts(:tour), FactoryData.comments(:woohoo).post
+    end
+  end
+end

data/test/lib/models.rb

@@ -0,0 +1,31 @@
+class EmailAddress < ActiveRecord::Base
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :comments
+  validates_presence_of :last_name
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+  has_many   :comments
+  has_many   :post_images
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :user
+end
+
+class PostImage < ActiveRecord::Base
+  belongs_to :post
+  has_many   :post_image_ratings
+end
+
+class PostImageRating < ActiveRecord::Base
+  belongs_to :post_image
+end
+
+class IpAddress < ActiveRecord::Base
+end

data/test/lib/schema.rb

@@ -0,0 +1,54 @@
+OutputCapturer.capture do
+  ActiveRecord::Schema.define do
+    create_table :email_addresses, :force => true do |t|
+      t.string   :address
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :users, :force => true do |t|
+      t.string   :first_name
+      t.string   :last_name
+      t.timestamps
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :posts, :force => true do |t|
+      t.references :user
+      t.string     :title
+      t.string     :body
+      t.timestamps
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :comments, :force => true do |t|
+      t.references :user
+      t.references :post
+      t.string     :comment
+      t.timestamps
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :post_images, :force => true do |t|
+      t.references :post
+      t.timestamps
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :post_image_ratings, :force => true do |t|
+      t.references :post_image
+      t.timestamps
+    end
+  end
+
+  ActiveRecord::Schema.define do
+    create_table :ip_addresses, :force => true do |t|
+      t.string     :ip_address
+      t.timestamps
+    end
+  end
+end

data/test/preloaded_data_hash_test.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PreloadedDataHashTest < Test::Unit::TestCase
+  def setup
+    FactoryDataPreloader.reset!
+  end
+
+  def self.test_add_valid_record(desc, &block)
+    context desc do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          @preloaded_data_hash.add(:record) { @user = instance_eval(&block) }
+        end
+      end
+
+      should 'print a dot' do
+        assert_equal '', @err
+        assert_equal '.', @out
+      end
+
+      should 'add the record id to the hash' do
+        assert_equal @user.id, @preloaded_data_hash[:record]
+      end
+    end
+  end
+
+  def self.test_add_invalid_record(desc, error_msg_regex, &block)
+    context desc do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          @preloaded_data_hash.add(:record) { instance_eval(&block) }
+        end
+      end
+
+      should 'print a warning message' do
+        assert_equal '', @err
+        assert_match /WARNING: an error occurred while preloading/, @out
+      end
+
+      should 'add an error message to the hash' do
+        assert @preloaded_data_hash[:record].is_a?(Exception)
+        assert_match error_msg_regex, @preloaded_data_hash[:record].message
+      end
+    end
+  end
+
+  context 'For a new preloader data hash' do
+    setup do
+      @preloaded_data_hash = PreloadedDataHash.new(stub_everything(:model_class => User))
+    end
+
+    test_add_valid_record('when a saved record is added') { User.create!(:first_name => 'Barack', :last_name => 'Obama') }
+    test_add_valid_record('when a valid unsaved record is added') { User.new(:first_name => 'Barack', :last_name => 'Obama') }
+    test_add_invalid_record('when an invalid unsaved record is added', /Error preloading factory data.*could not be saved/) { User.new }
+    test_add_invalid_record('when an error occurs while adding the preloading a record', /This is an error/) { raise 'This is an error' }
+
+    context 'adding a record through the deprecated []= method' do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          @preloaded_data_hash[:record] = (@user = User.create!(:first_name => 'Barack', :last_name => 'Obama'))
+        end
+      end
+
+      should 'print a deprecation warning' do
+        assert_equal '', @err
+        assert_match /DEPRECATION WARNING: Instead of .* please use .*/, @out
+      end
+
+      should 'add the record id to the hash' do
+        assert_equal @user.id, @preloaded_data_hash[:record]
+      end
+    end
+
+    context 'when multiple records and errors have been added' do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          @preloaded_data_hash.add(:barack) { @barack = User.create!(:first_name => 'Barack', :last_name => 'Obama') }
+          @preloaded_data_hash.add(:error)  { raise 'An error' }
+          @preloaded_data_hash.add(:george) { @george = User.create!(:first_name => 'George', :last_name => 'Washington') }
+        end
+      end
+
+      should 'return the record ids for #record_ids' do
+        assert_same_elements [@barack.id, @george.id], @preloaded_data_hash.record_ids
+      end
+    end
+  end
+end

data/test/preloader_test.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PreloaderTest < Test::Unit::TestCase
+  def setup
+    FactoryDataPreloader.reset!
+  end
+
+  context 'A new preloader' do
+    setup do
+      proc = lambda { |data|
+        data.add(:thom) { User.create(:first_name => 'Thom', :last_name => 'York') }
+        data.add(:john) { User.create(:first_name => 'John', :last_name => 'Doe') }
+      }
+      @preloader = FactoryDataPreloader::Preloader.new(:users, User, proc, [])
+    end
+
+    should 'be automatically added to the PreloaderCollection' do
+      assert_equal [@preloader], FactoryDataPreloader::AllPreloaders.instance
+    end
+
+    context 'when preloaded' do
+      setup do
+        @out, @err = OutputCapturer.capture do
+          @preloader.preload!
+        end
+      end
+
+      should_change 'User.count', :by => 2
+
+      should 'return the preloaded data when #get_record is called' do
+        assert_equal 'York', @preloader.get_record(:thom).last_name
+        assert_equal 'Doe',  @preloader.get_record(:john).last_name
+      end
+
+      should 'print out a preloader message, a dot for each record and a benchmark' do
+        assert_equal '', @err
+        assert_match /Preloading users:\.\.\([\d\.]+ secs\)/, @out
+      end
+
+      context 'when preloaded again' do
+        setup do
+          @out, @err = OutputCapturer.capture do
+            @preloader.preload!
+          end
+        end
+
+        should 'print nothing' do
+          assert_equal '', @err
+          assert_equal '', @out
+        end
+
+        should_not_change 'User.count'
+      end
+
+      should 'issue a delete statement if #delete_table_data! is called' do
+        User.expects(:delete_all).once
+        @preloader.delete_table_data!
+      end
+
+      context 'when #delete_table_data! is called' do
+        setup do
+          @preloader.delete_table_data!
+        end
+
+        should 'not issue another delete statement if #delete_table_data! is later called on the same preloader' do
+          User.expects(:delete_all).never
+          @preloader.delete_table_data!
+        end
+      end
+    end
+  end
+
+  context 'A new preloader for email_addresses' do
+    setup do
+      @preloader = FactoryDataPreloader::Preloader.new(:email_addresses, nil, lambda { }, [])
+    end
+
+    should 'infer the model class' do
+      assert_equal EmailAddress, @preloader.model_class
+    end
+  end
+
+  context 'A preloader with errors' do
+    setup do
+      proc = lambda { |data|
+        data.add(:thom) { raise StandardError('Error for thom') }
+        data.add(:john) { @john = User.create(:first_name => 'John', :last_name => 'Doe') }
+      }
+      @preloader = FactoryDataPreloader::Preloader.new(:users, User, proc, [])
+      @out, @err = OutputCapturer.capture do
+        @preloader.preload!
+      end
+    end
+
+    should 'raise an exception when the record with the error is accessed' do
+      assert_raise FactoryDataPreloader::ErrorWhilePreloadingRecord do
+        @preloader.get_record(:thom)
+      end
+    end
+
+    should 'allow the error-free records to be accessed, even when they were created after the error record' do
+      assert_equal @john, @preloader.get_record(:john)
+    end
+  end
+
+  context 'A preloader with dependencies' do
+    setup do
+      @comments = FactoryDataPreloader::Preloader.new(:comments, Comment, nil, [:users, :posts])
+    end
+
+    should 'raise PreloaderNotDefinedError for #dependencies if the preloader it depends on are not defined' do
+      assert_raise FactoryDataPreloader::PreloaderNotDefinedError do
+        @comments.dependencies
+      end
+    end
+
+    context 'when the dependency preloaders have also been defined' do
+      setup do
+        @posts = FactoryDataPreloader::Preloader.new(:posts, Post, nil, [:users])
+        @users = FactoryDataPreloader::Preloader.new(:users, User, nil, [])
+      end
+
+      should 'return the preloader objects for #dependencies' do
+        assert_equal [@users, @posts], @comments.dependencies
+      end
+    end
+  end
+
+  context 'A series of preloaders, with dependencies,' do
+    setup do
+      @post_image_ratings  = FactoryDataPreloader::Preloader.new(:post_image_ratings,  PostImageRating, nil, [:post_images])
+      @post_images         = FactoryDataPreloader::Preloader.new(:post_images,         PostImage,       nil, [:posts])
+      @ip_addresses        = FactoryDataPreloader::Preloader.new(:ip_addresses,        IpAddress,       nil, [])
+      @posts               = FactoryDataPreloader::Preloader.new(:posts,               Post,            nil, [:users])
+      @users               = FactoryDataPreloader::Preloader.new(:users,               User,            nil, [])
+    end
+
+    should 'sort correctly for PreloaderCollection.instance.dependency_order' do
+      expected = [@ip_addresses, @users, @posts, @post_images, @post_image_ratings]
+      assert_equal expected.map(&:model_type), FactoryDataPreloader::AllPreloaders.instance.dependency_order.map(&:model_type)
+    end
+
+    should 'return the correct preloader objects for #all_dependencies' do
+      assert_same_elements [@post_images, @posts, @users], @post_image_ratings.all_dependencies
+      assert_same_elements [@posts, @users], @post_images.all_dependencies
+      assert_same_elements [], @ip_addresses.all_dependencies
+      assert_same_elements [@users], @posts.all_dependencies
+      assert_same_elements [], @users.all_dependencies
+    end
+
+    context 'when FactoryDataPreloader.preload_all = true' do
+      setup do
+        FactoryDataPreloader.preload_all = true
+      end
+
+      should 'return all preloaders for FactoryDataPreloader.requested_preloaders' do
+        expected = [@ip_addresses, @users, @posts, @post_images, @post_image_ratings]
+        assert_equal expected.map(&:model_type), FactoryDataPreloader.requested_preloaders.dependency_order.map(&:model_type)
+      end
+    end
+
+    context 'when FactoryDataPreloader.preload_all = false' do
+      setup do
+        FactoryDataPreloader.preload_all = false
+      end
+
+      should 'return no preloaders when for FactoryDataPreloader.requested_preloaders when preload_types is empty' do
+        assert_equal [], FactoryDataPreloader.preload_types
+        assert_equal [], FactoryDataPreloader.requested_preloaders
+      end
+
+      should 'return just the requested preloaders for FactoryDataPreloader.requested_preloaders' do
+        FactoryDataPreloader.preload_types << :post_images
+        FactoryDataPreloader.preload_types << :ip_addresses
+        expected = [@ip_addresses, @users, @posts, @post_images]
+        assert_equal expected.map(&:model_type), FactoryDataPreloader.requested_preloaders.dependency_order.map(&:model_type)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+  Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+rescue LoadError
+  # ruby-debug wasn't available so neither can the debugging be
+end
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'factory_data_preloader'
+
+ActiveRecord::Base.establish_connection({ :database => ":memory:", :adapter => 'sqlite3', :timeout => 500 })
+
+module OutputCapturer
+  # borrowed from zentest assertions...
+  def self.capture
+    require 'stringio'
+    orig_stdout = $stdout.dup
+    orig_stderr = $stderr.dup
+    captured_stdout = StringIO.new
+    captured_stderr = StringIO.new
+    $stdout = captured_stdout
+    $stderr = captured_stderr
+    yield
+    captured_stdout.rewind
+    captured_stderr.rewind
+    return captured_stdout.string, captured_stderr.string
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+end
+
+module FactoryDataPreloader
+  def self.reset!
+    self.preload_all = true
+    self.preload_types = []
+
+    preloaders = Array.new(FactoryDataPreloader::AllPreloaders.instance)
+    preloaders.each do |preloader|
+      preloader.remove!
+    end
+
+    FactoryData.reset_cache!
+  end
+end
+
+require 'lib/schema'
+require 'lib/models'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: factory_data_preloader
+version: !ruby/object:Gem::Version 
+  version: 0.5.2
+platform: ruby
+authors: 
+- Myron Marston
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: Shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: myron.marston@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- CHANGELOG.rdoc
+- README.rdoc
+- VERSION.yml
+- lib/factory_data_preloader/core_ext.rb
+- lib/factory_data_preloader/factory_data.rb
+- lib/factory_data_preloader/preloaded_data_hash.rb
+- lib/factory_data_preloader/preloader.rb
+- lib/factory_data_preloader/preloader_collection.rb
+- lib/factory_data_preloader/rails_core_ext.rb
+- lib/factory_data_preloader.rb
+- test/factory_data_test.rb
+- test/lib/models.rb
+- test/lib/schema.rb
+- test/preloaded_data_hash_test.rb
+- test/preloader_test.rb
+- test/test_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/myronmarston/factory_data_preloader
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A library for preloading test data in rails applications.
+test_files: []
+