gabrielg-factory_girl 1.1.8 → 1.1.9

data/lib/factory_girl/factory.rb

@@ -1,5 +1,5 @@
 class Factory
-  
+
   cattr_accessor :factories #:nodoc:
   self.factories = {}
 
@@ -10,7 +10,7 @@ class Factory
   cattr_accessor :definition_file_paths
   self.definition_file_paths = %w(factories test/factories spec/factories)
 
-  attr_reader :factory_name
+  attr_reader :factory_name, :inherited_factory
 
   # Defines a new factory that can be used by the build strategies (create and
   # build) to build new objects.
@@ -20,14 +20,16 @@ class Factory
   #     A unique name used to identify this factory.
   #   options: (Hash)
   #     class: the class that will be used when generating instances for this
-  #            factory. If not specified, the class will be guessed from the 
+  #            factory. If not specified, the class will be guessed from the
   #            factory name.
   #
   # Yields:
   #    The newly created factory (Factory)
   def self.define (name, options = {})
     inherit_from = options.delete(:inherit)
-    instance = (inherit_from.nil?) ? Factory.new(name, options) : self.factories[inherit_from]
+    options = inherit_from ? options.merge(:inherit => factories[inherit_from]) : options
+    raise(ArgumentError, "Inherited factory not defined") if inherit_from && options[:inherit].blank?
+    instance = Factory.new(name, options)
     yield(instance)
     self.factories[instance.factory_name] = instance
   end
@@ -37,7 +39,7 @@ class Factory
   end
 
   def initialize (name, options = {}) #:nodoc:
-    options.assert_valid_keys(:class)
+    options.assert_valid_keys(:class, :inherit)
     @factory_name = factory_name_for(name)
     @options      = options
     @attributes   = []
@@ -45,6 +47,8 @@ class Factory
     @lazy_attribute_blocks = {}
     @lazy_attribute_names  = []
     @callbacks = {}
+    @inherited_factory = options[:inherit]
+    @options[:class] = inherited_factory.build_class if inherited_factory && !@options.has_key?(:class)
   end
 
   # Adds an attribute that should be assigned on generated instances for this
@@ -88,7 +92,7 @@ class Factory
   #     f.add_attribute :name, 'Billy Idol'
   #   end
   #
-  # are equivilent. 
+  # are equivilent.
   def method_missing (name, *args, &block)
     add_attribute(name, *args, &block)
   end
@@ -133,13 +137,16 @@ class Factory
   def create (attrs = {}) #:nodoc:
     instance, final_attrs = build_instance(attrs, :create)
     instance.save!
-    instance_exec(instance, final_attrs, &@callbacks[:after_create]) unless @callbacks[:after_create].nil?
+    if callback = @callbacks[:after_create]
+      params = (callback.arity > 1) ? [instance, final_attrs] : [instance]
+      instance_exec(*params, &callback)
+    end
     instance
   end
 
-  # Allows a block to be evaluated after the factory object has been built, but before 
-  # it is saved to the database.  The block is passed the instance so you can do stuff 
-  # to it. For example, maybe you want to stub a method whose result normally relies on 
+  # Allows a block to be evaluated after the factory object has been built, but before
+  # it is saved to the database.  The block is passed the instance so you can do stuff
+  # to it. For example, maybe you want to stub a method whose result normally relies on
   # complex computation on attributes and associations:
   #
   #   Factory.define :a_boy_that_never_goes_out, :class => Boy do |f|
@@ -152,7 +159,7 @@ class Factory
     @callbacks[:after_build] = block
   end
 
-  # Allows a block to be evaluated after the factory object has been saved to the 
+  # Allows a block to be evaluated after the factory object has been saved to the
   # database.  The block is passed the instance so you can do stuff to it. For example
   # maybe you want to stub a method whose result normally relies on complex computation
   # on attributes and associations:
@@ -239,13 +246,13 @@ class Factory
   def build_attributes_hash (values, strategy)
     values = values.symbolize_keys
     passed_keys = values.keys.collect {|key| Factory.aliases_for(key) }.flatten
-    @attributes.each do |attribute|
-      unless passed_keys.include?(attribute.name)
-        proxy = AttributeProxy.new(self, attribute.name, strategy, values)
-        values[attribute.name] = attribute.value(proxy)
-      end
+    attrs = @attributes.inject(values) do |vals,attribute|
+      next(vals) if passed_keys.include?(attribute.name)
+      proxy = AttributeProxy.new(self, attribute.name, strategy, vals)
+      vals[attribute.name] = attribute.value(proxy)
+      vals
     end
-    values
+    inherited_factory ? inherited_factory.attributes_for.merge(attrs) : attrs
   end
 
   def build_instance (override, strategy)
@@ -254,7 +261,10 @@ class Factory
     attrs.each do |attr, value|
       instance.send(:"#{attr}=", value) if instance.respond_to?(:"#{attr}=")
     end
-    instance_exec(instance, attrs, &@callbacks[:after_build]) unless @callbacks[:after_build].nil?
+    if callback = @callbacks[:after_build]
+      params = (callback.arity > 1) ? [instance, attrs] : [instance]
+      instance_exec(*params, &callback)
+    end
     [instance, attrs]
   end
 

data/test/factory_test.rb

@@ -46,13 +46,13 @@ class FactoryTest < Test::Unit::TestCase
 
     should "add the factory to the list of factories" do
       Factory.define(@name) {|f| }
-      assert_equal Factory.factories[@name], 
+      assert_equal Factory.factories[@name],
                    @factory,
                    "Factories: #{Factory.factories.inspect}"
     end
 
   end
-  
+
   context "a factory" do
 
     setup do
@@ -68,7 +68,7 @@ class FactoryTest < Test::Unit::TestCase
     should "have a build class" do
       assert_equal @class, @factory.build_class
     end
-    
+
     should "have a set of callbacks" do
       assert @factory.instance_eval {@callbacks}
     end
@@ -77,6 +77,62 @@ class FactoryTest < Test::Unit::TestCase
       assert @factory.instance_eval {@callbacks.empty?}
     end
 
+    context "when inheriting from a prior factory" do
+      setup do
+        @factory.foo "bar"
+        @factory.snafu "foo"
+        @new_factory = Factory.new(:user_with_stuff, :inherit => @factory)
+        @new_factory.foo "fighters"
+        @instance = @new_factory.build
+      end
+
+      should "use subfactory's class if not specified" do
+        assert_equal User, @factory.build_class
+      end
+
+      should "allow overriding subfactory's class" do
+        newer_factory = Factory.new(:user_with_more_stuff, :inherit => @new_factory, :class => Post)
+        assert_equal Post, newer_factory.build_class
+      end
+
+      should "override previously configured attributes" do
+        assert_equal "fighters", @instance.foo
+      end
+
+      should "inherit attributes that arent overridden" do
+        assert_equal "foo", @instance.snafu
+      end
+
+    end
+
+    context "when defining an inheriting factory" do
+      setup do
+        @original_user_with_stuff_factory = Factory.factories[:user_with_stuff]
+      end
+
+      teardown do
+        Factory.factories[:user_with_stuff] = @original_user_with_stuff_factory
+      end
+
+      should "pass in an instance of the inherited factory as the inherited_factory" do
+        assert_not_nil Factory.factories[:user]
+        instance = Factory.define(:user_with_stuff, :inherit => :user) {}
+        assert_equal Factory.factories[:user], instance.inherited_factory
+      end
+
+      should "get its own factory definition" do
+        instance = Factory.define(:user_with_stuff, :inherit => :user) { }
+        assert_equal instance, Factory.factories[:user_with_stuff]
+      end
+
+      should "raise if inherited factory isnt found" do
+        assert_raise(ArgumentError) do
+          Factory.define(:user_with_stuff, :inherit => :foobar) { }
+        end
+      end
+
+    end
+
     context "when adding an after_build callback" do
       setup do
         @the_block = lambda{|u| }
@@ -86,7 +142,7 @@ class FactoryTest < Test::Unit::TestCase
       should "have something in the set of callbacks" do
         assert_equal 1, @factory.instance_eval {@callbacks.size}
       end
-      
+
       should "record the callback in the set of callbacks" do
         assert @factory.instance_eval {@callbacks.values}.include?(@the_block)
       end
@@ -94,6 +150,7 @@ class FactoryTest < Test::Unit::TestCase
       should "record the callback in the set of callbacks under the after_build key" do
         assert_equal @the_block, @factory.instance_eval {@callbacks[:after_build]}
       end
+
     end
 
     context "when adding an after_create callback" do
@@ -105,7 +162,7 @@ class FactoryTest < Test::Unit::TestCase
       should "have something in the set of callbacks" do
         assert_equal 1, @factory.instance_eval {@callbacks.size}
       end
-      
+
       should "record the callback in the set of callbacks" do
         assert @factory.instance_eval {@callbacks.values}.include?(@the_block)
       end
@@ -177,7 +234,7 @@ class FactoryTest < Test::Unit::TestCase
       end
 
       context "when other attributes have previously been defined" do
-        
+
         setup do
           @attr  = :unimportant
           @attrs = {
@@ -237,11 +294,11 @@ class FactoryTest < Test::Unit::TestCase
       end
 
     end
-        
+
     context "specifying an association on a factory with a count" do
       setup do
         Factory.define(:post) { |f| f.name "Article" }
-        Factory.define(:user) do |u| 
+        Factory.define(:user) do |u|
           u.first_name "Joe"
           u.last_name "Bloggs"
           u.email "joe@example.com"
@@ -249,20 +306,20 @@ class FactoryTest < Test::Unit::TestCase
         end
         @user = Factory(:user)
       end
-      
+
       should "set up five associated post objects" do
         assert_equal 5, @user.posts.size
       end
-      
+
       should "have the user as the author on each object" do
         @user.posts.each { |p| assert_equal @user, p.author }
       end
-      
+
       should "have saved all the posts" do
         @user.posts.each { |p| assert !p.new_record? }
       end
-      
-    end 
+
+    end
 
     should "add an attribute using the method name when passed an undefined method" do
       @attr  = :first_name
@@ -380,84 +437,111 @@ class FactoryTest < Test::Unit::TestCase
       end
 
       context "and an after_build callback has been registered" do
+        saved = nil
         setup do
-          @the_block = lambda {|user| assert user.new_record?; @saved = user}
-          
+          @the_block = lambda {|user| assert user.new_record?; saved = user}
+
           @factory.after_build &@the_block
         end
-        
+
         should "call the callback when the object is built" do
-          @the_block.expects(:call).once
+          @factory.expects(:instance_exec)
           @factory.build
         end
 
         should "call the callback when the object is created" do
-          @the_block.expects(:call).once
+          @factory.expects(:instance_exec)
           @factory.create
         end
 
+        should "yield the instance to block if block arity is <= 1" do
+          @factory.after_build(&(lambda{|user|}))
+          @factory.expects(:instance_exec).with(anything)
+          @factory.build
+        end
+
+        should "yield the instance and attrs to block if block arity is > 1" do
+          @factory.after_build(&(lambda{|user,attrs|}))
+          @factory.expects(:instance_exec).with(anything, instance_of(Hash))
+          @factory.build
+        end
+
         should "yield the instance to the callback when called" do
           instance = @factory.build
-          assert_equal @saved, instance
+          assert_equal saved, instance
         end
       end
 
       context "and an after_create callback has been registered" do
+        saved = nil
         setup do
-          @the_block = lambda {|user| assert !user.new_record?; @saved = user}
-          
+          @the_block = lambda {|user| assert !user.new_record?; saved = user}
+
           @factory.after_create &@the_block
         end
-        
+
         should "not call the callback when the object is built" do
           @the_block.expects(:call).never
           @factory.build
         end
 
         should "call the callback when the object is created" do
-          @the_block.expects(:call).once
+          @factory.expects(:instance_exec)
+          @factory.create
+        end
+
+        should "yield the instance to block if block arity is <= 1" do
+          @factory.after_create(&(lambda{|user|}))
+          @factory.expects(:instance_exec).with(anything)
+          @factory.create
+        end
+
+        should "yield the instance and attrs to block if block arity is > 1" do
+          @factory.after_create(&(lambda{|user,attrs|}))
+          @factory.expects(:instance_exec).with(anything, instance_of(Hash))
           @factory.create
         end
 
         should "yield the instance to the callback when called" do
           instance = @factory.create
-          assert_equal @saved, instance
+          assert_equal saved, instance
         end
       end
 
       context "and both after_build and after_create callbacks have been registered" do
+        post_build, = post_create = nil
         setup do
-          @the_after_build_block = lambda {|user| assert user.new_record?; @post_build = user}
-          @the_after_create_block = lambda {|user| assert !user.new_record?; @post_create = user}
-          
+          test = self
+          @the_after_build_block = lambda {|user| test.assert(user.new_record?); post_build = user}
+          @the_after_create_block = lambda {|user| test.assert(!user.new_record?); post_create = user}
+
           @factory.after_build &@the_after_build_block
           @factory.after_create &@the_after_create_block
         end
-        
+
         should "only call the after_build callback when the object is built" do
-          @the_after_build_block.expects(:call).once
-          @the_after_create_block.expects(:call).never
+          @factory.expects(:instance_exec).once
           @factory.build
         end
 
         should "call both callbacks when the object is created" do
-          @the_after_build_block.expects(:call).once
-          @the_after_create_block.expects(:call).once
+          @factory.expects(:instance_exec).at_least(2)
           @factory.create
         end
 
         should "yield the same instance to each callback when called" do
           instance = @factory.create
-          assert_equal @post_build, instance
-          assert_equal @post_create, instance
-          assert_equal @post_create, @post_build
+          assert_equal post_build, instance
+          assert_equal post_create, instance
+          assert_equal post_create, post_build
         end
-        
+
         should "call the after_build callback before the after_create callback when objects are created" do
           # TODO - is this good enough to detect "beforeness"?
-          @the_after_build_block = lambda {|user| assert_nil @post_build; assert_nil @post_create; @post_build = user}
-          @the_after_create_block = lambda {|user| assert_not_nil @post_build; assert_nil @post_create; @post_create = user}
-          
+          test = self
+          @the_after_build_block = lambda {|user| test.assert_nil @post_build; test.assert_nil @post_create; @post_build = user}
+          @the_after_create_block = lambda {|user| test.assert_not_nil @post_build; test.assert_nil @post_create; @post_create = user}
+
           @factory.after_build &@the_after_build_block
           @factory.after_create &@the_after_create_block
           @factory.create
@@ -477,7 +561,7 @@ class FactoryTest < Test::Unit::TestCase
         end
 
       end
-      
+
       context "when creating an instance" do
 
         setup do

data/test/models.rb

@@ -22,6 +22,7 @@ end
 CreateSchema.suppress_messages { CreateSchema.migrate(:up) }
 
 class User < ActiveRecord::Base
+  attr_accessor :foo, :snafu
   validates_presence_of :first_name, :last_name, :email
   has_many :posts, :foreign_key => 'author_id', :validate => false
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gabrielg-factory_girl
 version: !ruby/object:Gem::Version 
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors: 
 - Joe Ferris