myronmarston-factory_data_preloader 0.1.0

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,80 @@
+= 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.
+
+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.  Simply require the file(s) that define the preloaded data in your test/test_helper.rb.
+Define your data 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')
+  end
+
+  FactoryData.preload(:posts) do |data|
+    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|
+    # 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|
+    data[:woohoo] = FactoryData.users(:john).comments.create(:post => FactoryData.posts(:tour), :comment => "I can't wait!")
+  end
+
+Finally, use this preloaded data in your tests:
+
+  class UserTest < ActiveSupport::TestCase
+    def test_thom_has_last_name
+      user = FactoryData.users(:thom)
+      assert_equal 'York', user.last_name
+    end
+  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
+  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.
+* 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.
+* 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.
+
+== Copyright
+
+Copyright (c) 2009 Myron Marston, Kashless.org. See LICENSE for details.

data/VERSION.yml

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

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,84 @@
+require 'ostruct'
+
+class PreloaderAlreadyDefinedError < StandardError; end
+class PreloadedRecordNotFound < StandardError; end
+
+class FactoryData
+  @@preloaded_cache = nil
+  @@preloaded_data_deleted = nil
+  @@single_test_cache = {}
+  @@preloaders = []
+  
+  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)
+      
+      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) 
+
+      class << self; self; end.class_eval do
+        define_method model_type do |key|
+          get_record(model_type, model_class, key)
+        end
+      end
+    end
+
+    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
+    
+      @@preloaded_data_deleted = true
+    end
+
+    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
+        
+          cache[key] = record.id
+        end
+      end
+    end
+  
+    def reset_cache!
+      @@single_test_cache = {}
+    end
+
+    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
+      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
+end

data/lib/factory_data_preloader/rails_core_ext.rb

@@ -0,0 +1,33 @@
+# 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

data/lib/factory_data_preloader.rb

@@ -0,0 +1,16 @@
+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/factory_data'
+require 'factory_data_preloader/rails_core_ext'

data/test/factory_data_test.rb

@@ -0,0 +1,156 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FactoryDataTest < Test::Unit::TestCase  
+  def setup
+    FactoryData.reset!
+  end
+  
+  context 'Calling FactoryData.preload(:users)' do
+    setup do
+      FactoryData.preload(:users) do |data|
+        data[: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 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! }
+      
+      should_change 'User.count', :by => 1
+      
+      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 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 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')
+      end
+      FactoryData.preload_data!
+    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' 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')
+      end
+      
+      FactoryData.preload(:posts) 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!")
+      end
+      
+      FactoryData.preload_data!
+    end
+    
+    should 'preload them in the defined order, allowing you to use prior definitions in later definitions' do
+      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,14 @@
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :comments
+  validates_presence_of :last_name
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :user
+end

data/test/lib/schema.rb

@@ -0,0 +1,27 @@
+OutputCapturer.capture do
+  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
+end

data/test/test_helper.rb

@@ -0,0 +1,62 @@
+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
+
+class FactoryData
+  # helper method to reset the factory data between test runs.
+  def self.reset!
+    @@preloaders.reverse.each do |preloader|
+      class << self; self; end.class_eval do 
+        remove_method(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 = {}
+    @@preloaders = []
+  end
+end
+
+require 'lib/schema'
+require 'lib/models'

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: myronmarston-factory_data_preloader
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Myron Marston
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-30 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: myron.marston@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- 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/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/test_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/myronmarston/factory_data_preloader
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A library for preloading test data in rails applications.
+test_files: []
+