myronmarston-factory_data_preloader 0.1.0 → 0.2.0

data/README.rdoc

@@ -6,7 +6,7 @@ fixtures don't represent "real data".  Fixtures just dump the data you've define
 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.
+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.  
@@ -38,16 +38,18 @@ Define your data like this:
     data[:john] = User.create(:first_name => 'John', :last_name => 'Doe')
   end
 
-  FactoryData.preload(:posts) do |data|
+  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.')
   end
   
-  FactoryData.preload(:some_other_posts, :model_class => Post) do |data|
+  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')
   end
 
-  FactoryData.preload(:comments) do |data|
+  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!")
   end
 
@@ -70,10 +72,13 @@ Finally, use this preloaded data in your tests:
 * 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.
-* The data gets preloaded in the order the preloaders are defined.  Note in the example above that the users defined in
-  the first preloader get used in the later preloaders.
+* 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.
 
 == Copyright
 

data/VERSION.yml

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

data/lib/factory_data_preloader/factory_data.rb

@@ -1,84 +1,88 @@
 require 'ostruct'
 
-class PreloaderAlreadyDefinedError < StandardError; end
-class PreloadedRecordNotFound < StandardError; end
+module FactoryDataPreloader
+  class PreloaderAlreadyDefinedError < StandardError; end
+  class PreloadedRecordNotFound < StandardError; end
 
-class FactoryData
-  @@preloaded_cache = nil
-  @@preloaded_data_deleted = nil
-  @@single_test_cache = {}
-  @@preloaders = []
+  class FactoryData
+    @@preloaded_cache = nil
+    @@preloaded_data_deleted = nil
+    @@single_test_cache = {}
+    @@preloaders = []
   
-  class << self
+    class << self
 
-    def preload(model_type, options = {}, &block)
-      raise PreloaderAlreadyDefinedError.new, "You have already defined the preloader for #{model_type.to_s}" if @@preloaders.map(&:model_type).include?(model_type)
+      def preload(model_type, options = {}, &proc)
+        raise PreloaderAlreadyDefinedError.new, "You have already defined the preloader for #{model_type.to_s}" if @@preloaders.map(&:model_type).include?(model_type)
       
-      model_class = options[:model_class] || model_type.to_s.singularize.classify.constantize
-      @@preloaders << OpenStruct.new(:model_type => model_type, :model_class => model_class, :proc => block) 
+        model_class = options[:model_class] || model_type.to_s.singularize.classify.constantize
+        depends_on = [options[:depends_on]].compact.flatten
+        @@preloaders << FactoryDataPreloader::Preloader.new(model_type, model_class, proc, @@preloaders.size, depends_on)
 
-      class << self; self; end.class_eval do
-        define_method model_type do |key|
-          get_record(model_type, model_class, key)
+        class << self; self; end.class_eval do
+          define_method model_type do |key|
+            get_record(model_type, model_class, key)
+          end
         end
       end
-    end
 
-    def delete_preload_data!
-      # make sure this only runs once...
-      return unless @@preloaded_data_deleted.nil?
+      def delete_preload_data!
+        # make sure this only runs once...
+        return unless @@preloaded_data_deleted.nil?
     
-      # the preloaders are listed in the parent -> child table order,
-      # so we need to delete them in reverse.
-      @@preloaders.reverse.each do |preloader|
-        preloader.model_class.delete_all
-      end
+        # the preloaders are listed in the parent -> child table order,
+        # so we need to delete them in reverse.
+        @@preloaders.sort.reverse.each do |preloader|
+          preloader.model_class.delete_all
+        end
     
-      @@preloaded_data_deleted = true
-    end
+        @@preloaded_data_deleted = true
+      end
 
-    def preload_data!
-      return unless @@preloaded_cache.nil? # make sure the data is only preloaded once.
-      @@preloaded_cache = {}
+      def preload_data!
+        return unless @@preloaded_cache.nil? # make sure the data is only preloaded once.
+        @@preloaded_cache = {}
     
-      @@preloaders.each do |preloader|
-        cache = @@preloaded_cache[preloader.model_type] ||= {}
-        data = {}
-        preloader.proc.try(:call, data)
-        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
+        @@preloaders.sort.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
+            cache[key] = record.id
+          end
         end
       end
-    end
   
-    def reset_cache!
-      @@single_test_cache = {}
-    end
+      def reset_cache!
+        @@single_test_cache = {}
+      end
 
-    private
+      private
 
-    def get_record(type, model_class, key)
-      @@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
+      def get_record(type, model_class, key)
+        @@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
-    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
+      # 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
   end
-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/preloader.rb

@@ -0,0 +1,27 @@
+module FactoryDataPreloader
+  class Preloader
+    attr_accessor :model_type, :model_class, :proc, :defined_index, :depends_on
+  
+    def initialize(model_type, model_class, proc, defined_index, depends_on)
+      @model_type, @model_class, @proc, @defined_index, @depends_on = model_type, model_class, proc, defined_index, depends_on || []
+    end
+  
+    def data
+      @data ||= begin
+        data = {}
+        self.proc.try(:call, data)
+        data
+      end
+    end
+    
+    def <=>(preloader)
+      if self.depends_on.include?(preloader.model_type)
+        1
+      elsif preloader.depends_on.include?(self.model_type)
+        -1
+      else
+        self.defined_index <=> preloader.defined_index
+      end
+    end
+  end
+end

data/lib/factory_data_preloader.rb

@@ -12,5 +12,6 @@ require 'active_record'
 require 'active_record/fixtures'
 
 require 'factory_data_preloader/core_ext'
+require 'factory_data_preloader/preloader'
 require 'factory_data_preloader/factory_data'
 require 'factory_data_preloader/rails_core_ext'

data/test/factory_data_test.rb

@@ -16,7 +16,7 @@ class FactoryDataTest < Test::Unit::TestCase
     should_change "FactoryData.methods.include?('users')", :from => false, :to => true
     
     should 'not allow it to be called again' do
-      assert_raise PreloaderAlreadyDefinedError do
+      assert_raise FactoryDataPreloader::PreloaderAlreadyDefinedError do
         FactoryData.preload(:users)
       end
     end
@@ -54,7 +54,7 @@ class FactoryDataTest < Test::Unit::TestCase
         end
         
         should 'raise the appropriate error for a non-existant key' do
-          assert_raise PreloadedRecordNotFound do
+          assert_raise FactoryDataPreloader::PreloadedRecordNotFound do
             FactoryData.users(:not_a_user)
           end
         end
@@ -125,25 +125,25 @@ class FactoryDataTest < Test::Unit::TestCase
     end
   end
   
-  context 'Preloading multiple record types' do
+  context 'Preloading multiple record types, with dependencies' do
     setup do
-      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')
+      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!")
       end
       
-      FactoryData.preload(:posts) do |data|
+      FactoryData.preload(:posts, :depends_on => :users) do |data|
         data[:tour] = FactoryData.users(:thom).posts.create(:title => 'Tour!', :body => 'Radiohead will tour soon.')
       end
       
-      FactoryData.preload(:comments) do |data|
-        data[:woohoo] = FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!")
+      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
       
       FactoryData.preload_data!
     end
     
-    should 'preload them in the defined order, allowing you to use prior definitions in later definitions' do
+    should 'preload them in the proper order, allowing you to use the dependencies' do
       assert_equal 'Thom', FactoryData.users(:thom).first_name
       assert_equal 'John', FactoryData.users(:john).first_name
       

data/test/preloader_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FactoryDataTest < 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')
+      }
+      @preloader = FactoryDataPreloader::Preloader.new(:users, User, proc, 0, [])
+    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
+  end
+  
+  context 'Post and user preloaders, where post depends on users' do
+    setup do
+      @posts = FactoryDataPreloader::Preloader.new(:posts, Post, nil, 0, [:users])
+      @users = FactoryDataPreloader::Preloader.new(:users, User, nil, 1, [])
+    end
+    
+    should 'return a comparison value indicating that users is less than posts' do
+      assert_equal -1, @users <=> @posts
+      assert_equal  1, @posts <=> @users
+    end
+  end
+  
+  context 'Post and user preloaders, where neither post depends on the other' do
+    setup do
+      @posts = FactoryDataPreloader::Preloader.new(:posts, Post, nil, 0, [])
+      @users = FactoryDataPreloader::Preloader.new(:users, User, nil, 1, [])
+    end
+    
+    should 'return a comparison value based on their defined index' do
+      assert_equal  1, @users <=> @posts
+      assert_equal -1, @posts <=> @users
+    end
+  end
+end

data/test/test_helper.rb

@@ -38,7 +38,7 @@ module OutputCapturer
   end
 end
 
-class FactoryData
+class FactoryDataPreloader::FactoryData
   # helper method to reset the factory data between test runs.
   def self.reset!
     @@preloaders.reverse.each do |preloader|
@@ -47,7 +47,7 @@ class FactoryData
       end
       
       unless @@preloaded_cache.nil?
-        preloader.model_class.delete_all(:id => @@preloaded_cache[preloader.model_type].values)
+        preloader.model_class.delete_all(:id => (@@preloaded_cache[preloader.model_type] || {}).values)
       end
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: myronmarston-factory_data_preloader
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Myron Marston
@@ -28,12 +28,14 @@ files:
 - lib/factory_data_preloader
 - lib/factory_data_preloader/core_ext.rb
 - lib/factory_data_preloader/factory_data.rb
+- lib/factory_data_preloader/preloader.rb
 - lib/factory_data_preloader/rails_core_ext.rb
 - lib/factory_data_preloader.rb
 - test/factory_data_test.rb
 - test/lib
 - test/lib/models.rb
 - test/lib/schema.rb
+- test/preloader_test.rb
 - test/test_helper.rb
 - LICENSE
 has_rdoc: true