masa-iwasaki-factory_girl 1.2.1.1 → 1.2.3.1

data/lib/factory_girl/proxy/build.rb

@@ -22,6 +22,7 @@ class Factory
       end
 
       def result
+        run_callbacks(:after_build)
         @instance
       end
     end

data/lib/factory_girl/proxy/create.rb

@@ -1,10 +1,62 @@
 class Factory
   class Proxy #:nodoc:
     class Create < Build #:nodoc:
+      cattr_reader :instances
+      @@instances = {}
+
+      # Clear caches.
+      #
+      # You need to call this method (Or ::Factory.clear_caches) on every
+      # tearing down of a database in each test (e.g: RSpec).
+      #
+      # With RSpec, you may want to  call this method in global before block 
+      # in spec_helper.rb.
+      #
+      # Example 
+      #   config.before(:each) {
+      #     ::Factory.clear_caches
+      #   }
+      #
+      def self.clear_caches
+        @@instances = {}
+      end
+
       def result
-        @instance.save!
+        try
+      end
+
+      private
+      # Save new instance.
+      #
+      # If an exception occured during @instace.save!, rewrite error
+      # message to identify that which class has raised an exception easily.
+      def save_instance
+        run_callbacks(:after_build)
+        begin
+          @instance.save!
+          run_callbacks(:after_create)
+        rescue => e 
+          n = Exception.new("#{@instance.class.to_s} #{e.message}")
+          n.set_backtrace(e.backtrace)
+          raise n
+        end
         @instance
       end
+
+      # Try to use a cache. Instances to be cached is set :singleton
+      # option when you call Factory.define .
+      def try
+        if singleton
+          if @@instances[factory_name].nil? 
+            @@instances[factory_name] = save_instance
+          else
+            @@instances[factory_name]
+          end
+        else
+          save_instance
+        end
+      end
+
     end
   end
 end

data/lib/factory_girl/proxy/stub.rb

@@ -4,9 +4,9 @@ class Factory
       @@next_id = 1000
 
       def initialize(klass)
-        @stub = klass.new
-        @stub.id = next_id
-        @stub.instance_eval do
+        @instance = klass.new
+        @instance.id = next_id
+        @instance.instance_eval do
           def new_record?
             id.nil?
           end
@@ -26,11 +26,11 @@ class Factory
       end
 
       def get(attribute)
-        @stub.send(attribute)
+        @instance.send(attribute)
       end
 
       def set(attribute, value)
-        @stub.send(:"#{attribute}=", value)
+        @instance.send(:"#{attribute}=", value)
       end
 
       def associate(name, factory, attributes)
@@ -42,7 +42,8 @@ class Factory
       end
 
       def result
-        @stub
+        run_callbacks(:after_stub)
+        @instance
       end
     end
   end

data/lib/factory_girl/step_definitions.rb

@@ -0,0 +1,54 @@
+module FactoryGirlStepHelpers
+  def convert_association_string_to_instance(factory_name, assignment)
+    attribute, value = assignment.split(':', 2)
+    attributes = convert_human_hash_to_attribute_hash(attribute => value.strip)
+    factory = Factory.factory_by_name(factory_name)
+    model_class = factory.build_class
+    model_class.find(:first, :conditions => attributes) or
+      Factory(factory_name, attributes)
+  end
+
+  def convert_human_hash_to_attribute_hash(human_hash, associations = [])
+    human_hash.inject({}) do |attribute_hash, (human_key, value)|
+      key = human_key.downcase.gsub(' ', '_').to_sym
+      if association = associations.detect {|association| association.name == key }
+        value = convert_association_string_to_instance(association.factory, value)
+      end
+      attribute_hash.merge(key => value)
+    end
+  end
+end
+
+World(FactoryGirlStepHelpers)
+
+Factory.factories.values.each do |factory|
+  # TODO: support irregular pluralizations
+  Given /^the following #{factory.human_name}s? exists?:$/ do |table|
+    table.hashes.each do |human_hash|
+      attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)
+      Factory.create(factory.factory_name, attributes)
+    end
+  end
+
+  Given /^an? #{factory.human_name} exists$/ do
+    Factory(factory.factory_name)
+  end
+
+  Given /^(\d+) #{factory.human_name}s exist$/ do |count|
+    count.to_i.times { Factory(factory.human_name) }
+  end
+
+  if factory.build_class.respond_to?(:columns)
+    factory.build_class.columns.each do |column|
+      human_column_name = column.name.downcase.gsub('_', ' ')
+      Given /^an? #{factory.human_name} exists with an? #{human_column_name} of "([^"]*)"$/i do |value|
+        Factory(factory.factory_name, column.name => value)
+      end
+
+      Given /^(\d+) #{factory.human_name}s exist with an? #{human_column_name} of "([^"]*)"$/i do |count, value|
+        count.to_i.times { Factory(factory.factory_name, column.name => value) }
+      end
+    end
+  end
+end
+

data/spec/factory_girl/aliases_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Factory, "aliases" do
+
+  it "should include an attribute as an alias for itself by default" do
+    Factory.aliases_for(:test).should include(:test)
+  end
+
+  it "should include the root of a foreign key as an alias by default" do
+    Factory.aliases_for(:test_id).should include(:test)
+  end
+
+  it "should include an attribute's foreign key as an alias by default" do
+    Factory.aliases_for(:test).should include(:test_id)
+  end
+
+  describe "after adding an alias" do
+
+    before do
+      Factory.alias(/(.*)_suffix/, '\1')
+    end
+
+    it "should return the alias in the aliases list" do
+      Factory.aliases_for(:test_suffix).should include(:test)
+    end
+
+  end
+
+end

data/spec/factory_girl/attribute/association_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Attribute::Association do
+  before do
+    @name      = :author
+    @factory   = :user
+    @overrides = { :first_name => 'John' }
+    @attr      = Factory::Attribute::Association.new(@name, @factory, @overrides)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "should have a factory" do
+    @attr.factory.should == @factory
+  end
+
+  it "should tell the proxy to associate when being added to a proxy" do
+    proxy = "proxy"
+    stub(proxy).associate
+    @attr.add_to(proxy)
+    proxy.should have_received.associate(@name, @factory, @overrides)
+  end
+
+  it "should convert names to symbols" do
+    Factory::Attribute::Association.new('name', :user, {}).name.should == :name
+  end
+end

data/spec/factory_girl/attribute/callback_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Attribute::Callback do
+  before do
+    @name  = :after_create
+    @block = proc{ 'block' }
+    @attr  = Factory::Attribute::Callback.new(@name, @block)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "should set its callback on a proxy" do
+    @proxy = "proxy"
+    mock(@proxy).add_callback(@name, @block)
+    @attr.add_to(@proxy)
+  end
+
+  it "should convert names to symbols" do
+    Factory::Attribute::Callback.new('name', nil).name.should == :name
+  end
+end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Attribute::Dynamic do
+  before do
+    @name  = :first_name
+    @block = lambda { 'value' }
+    @attr  = Factory::Attribute::Dynamic.new(@name, @block)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "should call the block to set a value" do
+    @proxy = "proxy"
+    stub(@proxy).set
+    @attr.add_to(@proxy)
+    @proxy.should have_received.set(@name, 'value')
+  end
+
+  it "should yield the proxy to the block when adding its value to a proxy" do
+    @block = lambda {|a| a }
+    @attr  = Factory::Attribute::Dynamic.new(:user, @block)
+    @proxy = "proxy"
+    stub(@proxy).set
+    @attr.add_to(@proxy)
+    @proxy.should have_received.set(:user, @proxy)
+  end
+
+  it "should raise an error when defining an attribute writer" do
+    lambda {
+      Factory::Attribute::Dynamic.new('test=', nil)
+    }.should raise_error(Factory::AttributeDefinitionError)
+  end
+
+  it "should raise an error when returning a sequence" do
+    stub(Factory).sequence { Factory::Sequence.new }
+    block = lambda { Factory.sequence(:email) }
+    attr = Factory::Attribute::Dynamic.new(:email, block)
+    proxy = stub!.set.subject
+    lambda {
+      attr.add_to(proxy)
+    }.should raise_error(Factory::SequenceAbuseError)
+  end
+
+  it "should convert names to symbols" do
+    Factory::Attribute::Dynamic.new('name', nil).name.should == :name
+  end
+end

data/spec/factory_girl/attribute/static_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Attribute::Static do
+  before do
+    @name  = :first_name
+    @value = 'John'
+    @attr  = Factory::Attribute::Static.new(@name, @value)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "should set its static value on a proxy" do
+    @proxy = "proxy"
+    mock(@proxy).set(@name, @value)
+    @attr.add_to(@proxy)
+  end
+
+  it "should raise an error when defining an attribute writer" do
+    lambda {
+      Factory::Attribute::Static.new('test=', nil)
+    }.should raise_error(Factory::AttributeDefinitionError)
+  end
+
+  it "should convert names to symbols" do
+    Factory::Attribute::Static.new('name', nil).name.should == :name
+  end
+end

data/spec/factory_girl/attribute_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Factory::Attribute do
+  before do
+    @name  = :user
+    @attr  = Factory::Attribute.new(@name)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "should do nothing when being added to a proxy" do
+    @proxy = "proxy"
+    stub(@proxy).set
+    @attr.add_to(@proxy)
+    @proxy.should have_received.set.never
+  end
+
+  it "should raise an error when defining an attribute writer" do
+    error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
+    lambda {
+      Factory::Attribute.new('test=')
+    }.should raise_error(Factory::AttributeDefinitionError, error_message)
+  end
+
+  it "should convert names to symbols" do
+    Factory::Attribute.new('name').name.should == :name
+  end
+end

data/spec/factory_girl/factory_spec.rb

@@ -0,0 +1,582 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Factory do
+  describe "defining a factory" do
+    before do
+      @name    = :user
+      @factory = "factory"
+      stub(@factory).factory_name { @name }
+      @options = { :class => 'magic' }
+      stub(Factory).new { @factory }
+    end
+
+    after { Factory.factories.clear }
+
+    it "should create a new factory using the specified name and options" do
+      mock(Factory).new(@name, @options) { @factory }
+      Factory.define(@name, @options) {|f| }
+    end
+
+    it "should pass the factory do the block" do
+      yielded = nil
+      Factory.define(@name) do |y|
+        yielded = y
+      end
+      yielded.should == @factory
+    end
+
+    it "should add the factory to the list of factories" do
+      Factory.define(@name) {|f| }
+      @factory.should == Factory.factories[@name]
+    end
+
+    it "should allow a factory to be found by name" do
+      Factory.define(@name) {|f| }
+      Factory.factory_by_name(@name).should == @factory
+    end
+
+    it "should not allow a duplicate factory definition" do
+      lambda { 
+        2.times { Factory.define(@name) {|f| } }
+      }.should raise_error(Factory::DuplicateDefinitionError)
+    end
+
+  end
+
+  describe "a factory" do
+    before do
+      @name    = :user
+      @class   = User
+      @factory = Factory.new(@name)
+    end
+
+    it "should have a factory name" do
+      @factory.factory_name.should == @name
+    end
+
+    it "should have a build class" do
+      @factory.build_class.should == @class
+    end
+
+    it "should not allow the same attribute to be added twice" do
+      lambda {
+        2.times { @factory.add_attribute :first_name }
+      }.should raise_error(Factory::AttributeDefinitionError)
+    end
+
+    it "should add a static attribute when an attribute is defined with a value" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      mock(Factory::Attribute::Static).new(:name, 'value') { attribute }
+      @factory.add_attribute(:name, 'value')
+    end
+
+    it "should add a dynamic attribute when an attribute is defined with a block" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      block     = lambda {}
+      mock(Factory::Attribute::Dynamic).new(:name, block) { attribute }
+      @factory.add_attribute(:name, &block)
+    end
+
+    it "should raise for an attribute with a value and a block" do
+      lambda {
+        @factory.add_attribute(:name, 'value') {}
+      }.should raise_error(Factory::AttributeDefinitionError)
+    end
+
+    describe "adding an attribute using a in-line sequence" do
+      it "should create the sequence" do
+        mock(Factory::Sequence).new
+        @factory.sequence(:name) {}
+      end
+
+      it "should add a dynamic attribute" do
+        attribute = 'attribute'
+        stub(attribute).name { :name }
+        mock(Factory::Attribute::Dynamic).new(:name, is_a(Proc)) { attribute }
+        @factory.sequence(:name) {}
+        @factory.attributes.should include(attribute)
+      end
+    end
+
+    describe "adding a callback" do
+      it "should add a callback attribute when the after_build attribute is defined" do
+        mock(Factory::Attribute::Callback).new(:after_build, is_a(Proc)) { 'after_build callback' }
+        @factory.after_build {}
+        @factory.attributes.should include('after_build callback')
+      end
+
+      it "should add a callback attribute when the after_create attribute is defined" do
+        mock(Factory::Attribute::Callback).new(:after_create, is_a(Proc)) { 'after_create callback' }
+        @factory.after_create {}
+        @factory.attributes.should include('after_create callback')
+      end
+
+      it "should add a callback attribute when the after_stub attribute is defined" do
+        mock(Factory::Attribute::Callback).new(:after_stub, is_a(Proc)) { 'after_stub callback' }
+        @factory.after_stub {}
+        @factory.attributes.should include('after_stub callback')
+      end
+
+      it "should add a callback attribute when defining a callback" do
+        mock(Factory::Attribute::Callback).new(:after_create, is_a(Proc)) { 'after_create callback' }
+        @factory.callback(:after_create) {}
+        @factory.attributes.should include('after_create callback')
+      end
+
+      it "should raise an InvalidCallbackNameError when defining a callback with an invalid name" do
+        lambda{
+          @factory.callback(:invalid_callback_name) {}
+        }.should raise_error(Factory::InvalidCallbackNameError)
+      end
+    end
+
+    describe "after adding an attribute" do
+      before do
+        @attribute = "attribute"
+        @proxy     = "proxy"
+
+        stub(@attribute).name { :name }
+        stub(@attribute).add_to
+        stub(@proxy).set
+        stub(@proxy).result { 'result' }
+        stub(Factory::Attribute::Static).new { @attribute }
+        stub(Factory::Proxy::Build).new { @proxy }
+
+        mock(@proxy).factory_name=(:user)
+        mock(@proxy).singleton=(false)
+
+        @factory.add_attribute(:name, 'value')
+      end
+
+      it "should create the right proxy using the build class when running" do
+        mock(Factory::Proxy::Build).new(@factory.build_class) { @proxy }
+        @factory.run(Factory::Proxy::Build, {})
+      end
+
+      it "should add the attribute to the proxy when running" do
+        mock(@attribute).add_to(@proxy)
+        @factory.run(Factory::Proxy::Build, {})
+      end
+
+      it "should return the result from the proxy when running" do
+        mock(@proxy).result() { 'result' }
+        @factory.run(Factory::Proxy::Build, {}).should == 'result'
+      end
+    end
+
+    it "should add an association without a factory name or overrides" do
+      factory = Factory.new(:post)
+      name    = :user
+      attr    = 'attribute'
+      mock(Factory::Attribute::Association).new(name, name, {}) { attr }
+      factory.association(name)
+      factory.attributes.should include(attr)
+    end
+
+    it "should return associations" do
+      factory = Factory.new(:post)
+      factory.association(:author)
+      factory.association(:editor)
+      factory.associations.each do |association|
+        association.should be_a(Factory::Attribute::Association)
+      end
+      factory.associations.size.should == 2
+    end
+
+    it "should add an association with overrides" do
+      factory   = Factory.new(:post)
+      name      = :user
+      attr      = 'attribute'
+      overrides = { :first_name => 'Ben' }
+      mock(Factory::Attribute::Association).new(name, name, overrides) { attr }
+      factory.association(name, overrides)
+      factory.attributes.should include(attr)
+    end
+
+    it "should add an association with a factory name" do
+      factory = Factory.new(:post)
+      attr = 'attribute'
+      mock(Factory::Attribute::Association).new(:author, :user, {}) { attr }
+      factory.association(:author, :factory => :user)
+      factory.attributes.should include(attr)
+    end
+
+    it "should add an association with a factory name and overrides" do
+      factory = Factory.new(:post)
+      attr = 'attribute'
+      mock(Factory::Attribute::Association).new(:author, :user, :first_name => 'Ben') { attr }
+      factory.association(:author, :factory => :user, :first_name => 'Ben')
+      factory.attributes.should include(attr)
+    end
+
+    it "should raise for a self referencing association" do
+      factory = Factory.new(:post)
+      lambda {
+        factory.association(:parent, :factory => :post)
+      }.should raise_error(Factory::AssociationDefinitionError)
+    end
+
+    it "should add an attribute using the method name when passed an undefined method" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      block = lambda {}
+      mock(Factory::Attribute::Static).new(:name, 'value') { attribute }
+      @factory.send(:name, 'value')
+      @factory.attributes.should include(attribute)
+    end
+
+    it "should allow human_name as a static attribute name" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      mock(Factory::Attribute::Static).new(:human_name, 'value') { attribute}
+      @factory.human_name 'value'
+    end
+
+    it "should allow human_name as a dynamic attribute name" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      block     = lambda {}
+      mock(Factory::Attribute::Dynamic).new(:human_name, block) { attribute }
+      @factory.human_name(&block)
+    end
+
+    describe "when overriding generated attributes with a hash" do
+      before do
+        @attr  = :name
+        @value = 'The price is right!'
+        @hash  = { @attr => @value }
+      end
+
+      it "should return the overridden value in the generated attributes" do
+        @factory.add_attribute(@attr, 'The price is wrong, Bob!')
+        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
+        result[@attr].should == @value
+      end
+
+      it "should not call a lazy attribute block for an overridden attribute" do
+        @factory.add_attribute(@attr) { flunk }
+        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
+      end
+
+      it "should override a symbol parameter with a string parameter" do
+        @factory.add_attribute(@attr, 'The price is wrong, Bob!')
+        @hash = { @attr.to_s => @value }
+        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
+        result[@attr].should == @value
+      end
+    end
+
+    describe "overriding an attribute with an alias" do
+      before do
+        @factory.add_attribute(:test, 'original')
+        Factory.alias(/(.*)_alias/, '\1')
+        @result = @factory.run(Factory::Proxy::AttributesFor,
+                               :test_alias => 'new')
+      end
+
+      it "should use the passed in value for the alias" do
+        @result[:test_alias].should == 'new'
+      end
+
+      it "should discard the predefined value for the attribute" do
+        @result[:test].should be_nil
+      end
+    end
+
+    it "should guess the build class from the factory name" do
+      @factory.build_class.should == User
+    end
+
+    describe "when defined with a custom class" do
+      before do
+        @class   = User
+        @factory = Factory.new(:author, :class => @class)
+      end
+
+      it "should use the specified class as the build class" do
+        @factory.build_class.should == @class
+      end
+    end
+
+    describe "when defined with a class instead of a name" do
+      before do
+        @class   = ArgumentError
+        @name    = :argument_error
+        @factory = Factory.new(@class)
+      end
+
+      it "should guess the name from the class" do
+        @factory.factory_name.should == @name
+      end
+
+      it "should use the class as the build class" do
+        @factory.build_class.should == @class
+      end
+    end
+
+    describe "when defined with a custom class name" do
+      before do
+        @class   = ArgumentError
+        @factory = Factory.new(:author, :class => :argument_error)
+      end
+
+      it "should use the specified class as the build class" do
+        @factory.build_class.should == @class
+      end
+    end
+  end
+
+  describe "a factory with a name ending in s" do
+    before do
+      @name    = :business
+      @class   = Business
+      @factory = Factory.new(@name)
+    end
+
+    it "should have a factory name" do
+      @factory.factory_name.should == @name
+    end
+
+    it "should have a build class" do
+      @factory.build_class.should == @class
+    end
+  end
+
+  describe "a factory with a string for a name" do
+    before do
+      @name    = :user
+      @factory = Factory.new(@name.to_s) {}
+    end
+
+    it "should convert the string to a symbol" do
+      @factory.factory_name.should == @name
+    end
+  end
+
+  describe "a factory defined with a string name" do
+    before do
+      Factory.factories = {}
+      @name    = :user
+      @factory = Factory.define(@name.to_s) {}
+    end
+
+    it "should store the factory using a symbol" do
+      Factory.factories[@name].should == @factory
+    end
+  end
+
+  describe "after defining a factory" do
+    before do
+      @name    = :user
+      @factory = "factory"
+
+      Factory.factories[@name] = @factory
+    end
+
+    after { Factory.factories.clear }
+
+    it "should use Proxy::AttributesFor for Factory.attributes_for" do
+      mock(@factory).run(Factory::Proxy::AttributesFor, :attr => 'value') { 'result' }
+      Factory.attributes_for(@name, :attr => 'value').should == 'result'
+    end
+
+    it "should use Proxy::Build for Factory.build" do
+      mock(@factory).run(Factory::Proxy::Build, :attr => 'value') { 'result' }
+      Factory.build(@name, :attr => 'value').should == 'result'
+    end
+
+    it "should use Proxy::Create for Factory.create" do
+      mock(@factory).run(Factory::Proxy::Create, :attr => 'value') { 'result' }
+      Factory.create(@name, :attr => 'value').should == 'result'
+    end
+
+    it "should use Proxy::Stub for Factory.stub" do
+      mock(@factory).run(Factory::Proxy::Stub, :attr => 'value') { 'result' }
+      Factory.stub(@name, :attr => 'value').should == 'result'
+    end
+
+    it "should use default strategy option as Factory.default_strategy" do
+      stub(@factory).default_strategy { :create }
+      mock(@factory).run(Factory::Proxy::Create, :attr => 'value') { 'result' }
+      Factory.default_strategy(@name, :attr => 'value').should == 'result'
+    end
+
+    it "should use the default strategy for the global Factory method" do
+      stub(@factory).default_strategy { :create }
+      mock(@factory).run(Factory::Proxy::Create, :attr => 'value') { 'result' }
+      Factory(@name, :attr => 'value').should == 'result'
+    end
+
+    [:build, :create, :attributes_for, :stub].each do |method|
+      it "should raise an ArgumentError on #{method} with a nonexistant factory" do
+        lambda { Factory.send(method, :bogus) }.should raise_error(ArgumentError)
+      end
+
+      it "should recognize either 'name' or :name for Factory.#{method}" do
+        stub(@factory).run
+        lambda { Factory.send(method, @name.to_s) }.should_not raise_error
+        lambda { Factory.send(method, @name.to_sym) }.should_not raise_error
+      end
+    end
+  end
+
+  describe 'defining a factory with a parent parameter' do
+    before do
+      @parent = Factory.define :object do |f|
+        f.name  'Name'
+      end
+    end
+
+    after { Factory.factories.clear }
+
+    it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
+      lambda {
+        Factory.define(:child, :parent => :nonexsitent) {}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should create a new factory using the class of the parent" do
+      child = Factory.define(:child, :parent => :object) {}
+      child.build_class.should == @parent.build_class
+    end
+
+    it "should create a new factory while overriding the parent class" do
+      class Other; end
+
+      child = Factory.define(:child, :parent => :object, :class => Other) {}
+      child.build_class.should == Other
+    end
+
+    it "should create a new factory with attributes of the parent" do
+      child = Factory.define(:child, :parent => :object) {}
+      child.attributes.size.should == 1
+      child.attributes.first.name.should == :name
+    end
+
+    it "should allow to define additional attributes" do
+      child = Factory.define(:child, :parent => :object) do |f|
+        f.email 'person@somebody.com'
+      end
+      child.attributes.size.should == 2
+    end
+
+    it "should allow to override parent attributes" do
+      child = Factory.define(:child, :parent => :object) do |f|
+        f.name { 'Child Name' }
+      end
+      child.attributes.size.should == 1
+      child.attributes.first.should be_kind_of(Factory::Attribute::Dynamic)
+    end
+
+    it "inherit all callbacks" do
+      Factory.define(:child, :parent => :object) do |f|
+        f.after_stub {|o| o.name = 'Stubby' }
+      end
+
+      grandchild = Factory.define(:grandchild, :parent => :child) do |f|
+        f.after_stub {|o| o.name = "#{o.name} McStubby" }
+      end
+
+      grandchild.attributes.size.should == 3
+      grandchild.attributes.first.should be_kind_of(Factory::Attribute::Callback)
+      grandchild.attributes[1].should be_kind_of(Factory::Attribute::Callback)
+    end
+  end
+
+  describe 'defining a factory with a default strategy parameter' do
+    it "should raise an ArgumentError when trying to use a non-existent factory" do
+      lambda {
+        Factory.define(:object, :default_strategy => :nonexistent) {}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should create a new factory with a specified default strategy" do
+      factory = Factory.define(:object, :default_strategy => :stub) {}
+      factory.default_strategy.should == :stub
+    end
+  end
+
+  def self.in_directory_with_files(*files)
+    before do
+      @pwd = Dir.pwd
+      @tmp_dir = File.join(File.dirname(__FILE__), 'tmp')
+      FileUtils.mkdir_p @tmp_dir
+      Dir.chdir(@tmp_dir)
+
+      files.each do |file|
+        FileUtils.mkdir_p File.dirname(file)
+        FileUtils.touch file
+        stub(Factory).require(file)
+      end
+    end
+
+    after do
+      Dir.chdir(@pwd)
+      FileUtils.rm_rf(@tmp_dir)
+    end
+  end
+
+  def require_definitions_from(file)
+    simple_matcher do |given, matcher|
+      has_received = have_received.require(file)
+      result = has_received.matches?(given)
+      matcher.description = "require definitions from #{file}"
+      matcher.failure_message = has_received.failure_message
+      result
+    end
+  end
+
+  share_examples_for "finds definitions" do
+    before do
+      stub(Factory).require
+      Factory.find_definitions
+    end
+    subject { Factory }
+  end
+
+  describe "with factories.rb" do
+    in_directory_with_files 'factories.rb'
+    it_should_behave_like "finds definitions"
+    it { should require_definitions_from('factories.rb') }
+  end
+
+  %w(spec test).each do |dir|
+    describe "with a factories file under #{dir}" do
+      in_directory_with_files File.join(dir, 'factories.rb')
+      it_should_behave_like "finds definitions"
+      it { should require_definitions_from("#{dir}/factories.rb") }
+    end
+
+    describe "with a factories file under #{dir}/factories" do
+      in_directory_with_files File.join(dir, 'factories', 'post_factory.rb')
+      it_should_behave_like "finds definitions"
+      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+    end
+
+    describe "with several factories files under #{dir}/factories" do
+      in_directory_with_files File.join(dir, 'factories', 'post_factory.rb'),
+                              File.join(dir, 'factories', 'person_factory.rb')
+      it_should_behave_like "finds definitions"
+      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+      it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+    end
+
+    describe "with nested and unnested factories files under #{dir}" do
+      in_directory_with_files File.join(dir, 'factories.rb'),
+                              File.join(dir, 'factories', 'post_factory.rb'),
+                              File.join(dir, 'factories', 'person_factory.rb')
+      it_should_behave_like "finds definitions"
+      it { should require_definitions_from("#{dir}/factories.rb") }
+      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+      it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+    end
+  end
+
+  it "should return the factory name without underscores for the human name" do
+    factory = Factory.new(:name_with_underscores)
+    factory.human_name.should == 'name with underscores'
+  end
+
+end