myronmarston-factory_data_preloader 0.4.3 → 0.5.0

data/CHANGELOG.rdoc

@@ -0,0 +1,41 @@
+== 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/README.rdoc

@@ -34,23 +34,23 @@ Define your preloaded data.  FactoryData will automatically require test/factory
 Define your data in these files like 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')
+    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[:tour] = FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.')
+    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[:another_post] = Post.create(:user => FactoryData.users(:john), :title => 'Life is good')
+    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[:woohoo] = FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!")
+    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:
@@ -80,19 +80,19 @@ at the start of each test run.  If you want finer grain control over which prelo
   # test/user_test.rb
   class UserTest < ActiveSupport::TestCase
     preload_factory_data :users # multiple types can be listed as necessary
-    # test go here...
+    # 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.
-    # test go here...
+    # 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 gem or plugin you want.  In this contrived example, I just used ActiveRecord's
+* 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).
@@ -106,6 +106,26 @@ at the start of each test run.  If you want finer grain control over which prelo
 * 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
 

data/VERSION.yml

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

data/lib/factory_data_preloader.rb

@@ -14,6 +14,7 @@ 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'
 

data/lib/factory_data_preloader/factory_data.rb

@@ -4,12 +4,16 @@ module FactoryDataPreloader
   class PreloaderAlreadyDefinedError < StandardError; end
   class PreloadedRecordNotFound < StandardError; end
   class DefinedPreloaderNotRunError < StandardError; end
+  class ErrorWhilePreloadingRecord < StandardError; end
+
+  module DataMethods
+  end
 
   class FactoryData
-    @@preloaded_cache = nil
-    @@preloaded_data_deleted = nil
     @@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
@@ -18,47 +22,29 @@ module FactoryDataPreloader
       attr_accessor :definition_file_paths
 
       def preload(model_type, options = {}, &proc)
-        raise PreloaderAlreadyDefinedError.new, "You have already defined the preloader for #{model_type.to_s}" if AllPreloaders.instance.map(&:model_type).include?(model_type)
+        if existing_preloader = AllPreloaders.instance.from_symbol(model_type, false)
+          existing_preloader.remove!
+        end
 
-        model_class = options[:model_class] || model_type.to_s.singularize.classify.constantize
-        depends_on = [options[:depends_on]].compact.flatten
-        FactoryDataPreloader::Preloader.new(model_type, model_class, proc, depends_on)
+        FactoryDataPreloader::Preloader.new(model_type, options[:model_class], proc, options[:depends_on])
 
-        class << self; self; end.class_eval do
+        DataMethods.class_eval do
           define_method model_type do |key|
-            get_record(model_type, model_class, key)
+            FactoryData.send(:get_record, model_type, key)
           end
         end
       end
 
       def delete_preload_data!
-        # make sure this only runs once...
-        return unless @@preloaded_data_deleted.nil?
-
         # Delete them in the reverse order of the dependencies, to handle foreign keys
-        FactoryDataPreloader.requested_preloaders.reverse.each do |preloader|
+        FactoryDataPreloader.requested_preloaders.dependency_order.reverse.each do |preloader|
           preloader.model_class.delete_all
         end
-
-        @@preloaded_data_deleted = true
       end
 
       def preload_data!
-        return unless @@preloaded_cache.nil? # make sure the data is only preloaded once.
-        @@preloaded_cache = {}
-
         FactoryDataPreloader.requested_preloaders.dependency_order.each do |preloader|
-          cache = @@preloaded_cache[preloader.model_type] ||= {}
-          preloader.data.each do |key, record|
-            if record.new_record? && !record.save
-              puts "\nError preloading factory data.  #{preloader.model_class.to_s} :#{key.to_s} could not be saved.  Errors: "
-              puts pretty_error_messages(record)
-              puts "\n\n"
-              next
-            end
-
-            cache[key] = record.id
-          end
+          preloader.preload!
         end
       end
 
@@ -80,25 +66,10 @@ module FactoryDataPreloader
 
       private
 
-      def get_record(type, model_class, key)
-        if @@preloaded_cache[type].nil?
-          raise DefinedPreloaderNotRunError, "The :#{type} preloader has never been run.  Did you forget to add the 'preload_factory_data :#{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
-
-        @@single_test_cache[type] ||= {}
-        @@single_test_cache[type][key] ||= begin
-          record = model_class.find_by_id(@@preloaded_cache[type][key])
-          raise PreloadedRecordNotFound.new, "Could not find a record for FactoryData.#{type}(:#{key})." unless record
-          record
-        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
+      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
 

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

@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 module FactoryDataPreloader
   class PreloaderNotDefinedError < StandardError; end
 
@@ -11,50 +13,81 @@ module FactoryDataPreloader
     alias :preload_all? :preload_all
 
     def requested_preloaders
-      @requested_preloaders ||= begin
-        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
+      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_type, @model_class, @proc, @depends_on = 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
-    end
 
-    def data
-      @data ||= begin
-        data = PreloaderDataHash.new
-        print "Preloading #{model_type}:"
-        benchmark_measurement = Benchmark.measure { self.proc.try(:call, data) }
-        print "(#{format('%.3f', benchmark_measurement.real)} secs)\n"
-        data
+      DataMethods.class_eval do
+        define_method model_type do |key|
+          FactoryData.send(:get_record, model_type, key)
+        end
       end
     end
 
+    def preload!
+      @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 dependencies
-      @dependencies ||= self.depends_on.collect { |dependency| AllPreloaders.instance.from_symbol(dependency) }
+      self.depends_on.collect { |dependency| AllPreloaders.instance.from_symbol(dependency) }
     end
 
     def all_dependencies
-      @all_dependencies ||= (self.dependencies + (self.dependencies.collect { |d| d.all_dependencies }).flatten).uniq
+      (self.dependencies + (self.dependencies.collect { |d| d.all_dependencies }).flatten).uniq
     end
-  end
 
-  class PreloaderDataHash < Hash
-    def []=(key, value)
-      print "."
-      super
+    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} recore 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}"
+      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
 

data/lib/factory_data_preloader/preloader_collection.rb

@@ -15,9 +15,9 @@ module FactoryDataPreloader
       ordered_preloaders
     end
 
-    def from_symbol(symbol)
+    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."
+        raise PreloaderNotDefinedError, "The preloader for :#{symbol} has not been defined." if raise_error
       end
       preloader
     end

data/test/factory_data_test.rb

@@ -8,42 +8,52 @@ class FactoryDataTest < Test::Unit::TestCase
   context 'Calling FactoryData.preload(:users)' do
     setup do
       FactoryData.preload(:users) do |data|
-        data[:thom] = User.create(:first_name => 'Thom', :last_name => 'York')
+        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
 
-    should 'not allow it to be called again' do
-      assert_raise FactoryDataPreloader::PreloaderAlreadyDefinedError do
-        FactoryData.preload(:users)
-      end
-    end
-
     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
-
-        context 'and there is another record in the database' do
-          setup { User.create(:first_name => 'George', :last_name => 'Bush') }
-
-          context 'and FactoryData.delete_preload_data! is called again' do
-            setup { FactoryData.delete_preload_data! }
-            should_not_change 'User.count'
-          end
-        end
       end
     end
 
     context 'and later calling FactoryData.preload_data!' do
-      setup { FactoryData.preload_data! }
+      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) }
 
@@ -77,47 +87,14 @@ class FactoryDataTest < Test::Unit::TestCase
     end
   end
 
-  context 'Preloading a record that has not been saved' do
-    setup do
-      @unsaved_user = User.new(:first_name => 'George', :last_name => 'Washington')
-      assert @unsaved_user.new_record?
-
-      FactoryData.preload(:users) do |data|
-        data[:george] = @unsaved_user
-      end
-    end
-
-    should 'save the record wen preload_data! is called' do
-      FactoryData.preload_data!
-      assert !@unsaved_user.new_record?
-    end
-  end
-
-  context 'Preloading a record that cannot be saved to the database' do
-    setup do
-      @invalid_user = User.new(:first_name => 'Bob')
-      assert !@invalid_user.valid?
-
-      FactoryData.preload(:users) do |data|
-        data[:bob] = @invalid_user
-      end
-    end
-
-    should 'print an appropriate error message when preload_data! is called' do
-      out, err = OutputCapturer.capture do
-        FactoryData.preload_data!
-      end
-
-      assert_match /Error preloading factory data\.\s+User :bob could not be saved\.\s+Errors:\s+last_name can't be blank/im, out
-    end
-  end
-
   context 'Preloading with an explicit :model_class option' do
     setup do
       FactoryData.preload(:posts, :model_class => User) do |data|
-        data[:george] = User.create(:first_name => 'George', :last_name => 'Washington')
+        data.add(:george) { User.create(:first_name => 'George', :last_name => 'Washington') }
+      end
+      @out, @err = OutputCapturer.capture do
+        FactoryData.preload_data!
       end
-      FactoryData.preload_data!
     end
 
     should 'use the passed model_class rather than inferring the class from the symbol' do
@@ -128,23 +105,26 @@ class FactoryDataTest < Test::Unit::TestCase
   context 'Preloading multiple record types, with dependencies' do
     setup do
       FactoryData.preload(:comments, :depends_on => [:users, :posts]) do |data|
-        data[:woohoo] = FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!")
+        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[:tour] = FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.')
+        data.add(:tour) { FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.') }
       end
 
       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')
+        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
-      FactoryData.preload_data!
+
+      @out, @err = OutputCapturer.capture do
+        FactoryData.preload_data!
+      end
 
       assert FactoryData.users(:thom)
       assert_raise FactoryDataPreloader::DefinedPreloaderNotRunError do
@@ -153,7 +133,10 @@ class FactoryDataTest < Test::Unit::TestCase
     end
 
     should 'preload them in the proper order, allowing you to use the dependencies' do
-      FactoryData.preload_data!
+      @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
 

data/test/lib/models.rb

@@ -1,3 +1,6 @@
+class EmailAddress < ActiveRecord::Base
+end
+
 class User < ActiveRecord::Base
   has_many :posts
   has_many :comments

data/test/lib/schema.rb

@@ -1,4 +1,10 @@
 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

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

@@ -8,21 +8,66 @@ class PreloaderTest < Test::Unit::TestCase
   context 'A new preloader' do
     setup do
       proc = lambda { |data|
-        data[:thom] = User.create(:first_name => 'Thom', :last_name => 'York')
-        data[:john] = User.create(:first_name => 'John', :last_name => 'Doe')
+        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 'return the preloaded data for #data' do
-      data = @preloader.data
-      assert_equal 'York', data[:thom].last_name
-      assert_equal 'Doe',  data[:john].last_name
-    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 '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
+    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

data/test/test_helper.rb

@@ -42,28 +42,13 @@ module FactoryDataPreloader
   def self.reset!
     self.preload_all = true
     self.preload_types = []
-    @requested_preloaders = nil
-    FactoryData.reset!
-  end
-
-  class FactoryData
-    # helper method to reset the factory data between test runs.
-    def self.reset!
-      FactoryDataPreloader::AllPreloaders.instance.each do |preloader|
-        class << self; self; end.class_eval do
-          remove_method(preloader.model_type) if method_defined?(preloader.model_type)
-        end
 
-        unless @@preloaded_cache.nil?
-          preloader.model_class.delete_all(:id => (@@preloaded_cache[preloader.model_type] || {}).values)
-        end
-      end
-
-      @@preloaded_cache = nil
-      @@preloaded_data_deleted = nil
-      @@single_test_cache = {}
-      FactoryDataPreloader::AllPreloaders.instance.clear
+    preloaders = Array.new(FactoryDataPreloader::AllPreloaders.instance)
+    preloaders.each do |preloader|
+      preloader.remove!
     end
+
+    FactoryData.reset_cache!
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: myronmarston-factory_data_preloader
 version: !ruby/object:Gem::Version 
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors: 
 - Myron Marston
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-05 00:00:00 -07:00
+date: 2009-07-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,11 +42,13 @@ extra_rdoc_files:
 - README.rdoc
 - LICENSE
 files: 
+- CHANGELOG.rdoc
 - README.rdoc
 - VERSION.yml
 - lib/factory_data_preloader
 - 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
@@ -55,6 +57,7 @@ files:
 - test/lib
 - test/lib/models.rb
 - test/lib/schema.rb
+- test/preloaded_data_hash_test.rb
 - test/preloader_test.rb
 - test/test_helper.rb
 - LICENSE