factory_girl 1.3.3 → 2.0.0.beta1

data/spec/factory_girl/deprecated_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe "accessing an undefined method on Factory that is defined on FactoryGirl" do
+  let(:method_name) { :aliases }
+  let(:return_value) { 'value' }
+  let(:args) { [1, 2, 3] }
+
+  before do
+    stub($stderr).puts
+    stub(FactoryGirl, method_name).returns { return_value }
+
+    @result = Factory.send(method_name, *args)
+  end
+
+  it "prints a deprecation warning" do
+    $stderr.should have_received.puts(anything)
+  end
+
+  it "invokes that method on FactoryGirl" do
+    FactoryGirl.should have_received.method_missing(method_name, *args)
+  end
+
+  it "returns the value from the method on FactoryGirl" do
+    @result.should == return_value
+  end
+end
+
+describe "accessing an undefined method on Factory that is not defined on FactoryGirl" do
+  let(:method_name) { :magic_beans }
+
+  before do
+    stub($stderr).puts { raise "Don't print a deprecation warning" }
+
+    begin
+      Factory.send(method_name)
+    rescue Exception => @raised
+    end
+  end
+
+  it "raises a NoMethodError" do
+    @raised.should be_a(NoMethodError)
+  end
+end
+
+describe "accessing an undefined constant on Factory that is defined on FactoryGirl" do
+  before do
+    @result = Factory::VERSION
+  end
+
+  it "returns that constant on FactoryGirl" do
+    @result.should == FactoryGirl::VERSION
+  end
+end
+
+describe "accessing an undefined constant on Factory that is undefined on FactoryGirl" do
+  it "raises a NameError for Factory" do
+    begin
+      Factory::BOGUS
+    rescue Exception => exception
+    end
+
+    exception.should be_a(NameError)
+    exception.message.should include("Factory::BOGUS")
+  end
+end
+

data/spec/factory_girl/factory_spec.rb

@@ -1,677 +1,394 @@
 require 'spec_helper'
 
-describe Factory do
-  include DefinesConstants
-
+describe FactoryGirl::Factory, "registering a factory" do
   before do
-    define_constant('User')
-    define_constant('Admin', User)
-    define_constant('Business')
-    define_constant('Admin::Settings')
+    @name    = :user
+    @factory = "factory"
+    stub(@factory).name { @name }
   end
 
-  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
-
+  it "should add the factory to the list of factories" do
+    FactoryGirl.register_factory(@factory)
+    FactoryGirl.factory_by_name(@name).should == @factory
   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 have a default strategy" do
-      @factory.default_strategy.should == :create
-    end
-
-    it "should return static attribute  when asked for a type" do
-      result = @factory.type
-      result.should be_kind_of(Array)
-      result.first.should be_kind_of(Factory::Attribute::Static)
-      result.first.name.should == :type
-    end
-
-    it "should define type as an attribute" do
-      @factory.type { "it's a type" }
-      attributes = @factory.attributes
-      attributes.should be_kind_of(Array)
-      attributes.size.should == 1
-      attributes.first.name.should == :type
-    end
-
-    it "should return static attribute when asked for the id" do
-      result = @factory.id
-      result.should be_kind_of(Array)
-      result.first.should be_kind_of(Factory::Attribute::Static)
-      result.first.name.should == :id
-    end
-
-    it "should define id as an attribute" do
-      @factory.id { "it's an id" }
-      attributes = @factory.attributes
-      attributes.should be_kind_of(Array)
-      attributes.size.should == 1
-      attributes.first.name.should == :id
-    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 not allow a duplicate factory definition" do
+    lambda {
+      2.times { FactoryGirl.register_factory(@factory) }
+    }.should raise_error(FactoryGirl::DuplicateDefinitionError)
+  end
+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
+describe FactoryGirl::Factory do
+  include DefinesConstants
 
-    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
+  before do
+    @name    = :user
+    @class   = define_constant('User')
+    @factory = FactoryGirl::Factory.new(@name)
+  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
+  it "should have a factory name" do
+    @factory.name.should == @name
+  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
+  it "responds to factory_name" do
+    @factory.factory_name.should == @name
+  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
+  it "should have a build class" do
+    @factory.build_class.should == @class
+  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 }
-
-        @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 have a default strategy" do
+    @factory.default_strategy.should == :create
+  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 not allow the same attribute to be added twice" do
+    lambda {
+      2.times { @factory.define_attribute FactoryGirl::Attribute::Static.new(:name, 'value') }
+    }.should raise_error(FactoryGirl::AttributeDefinitionError)
+  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 a callback attribute when defining a callback" do
+    mock(FactoryGirl::Attribute::Callback).new(:after_create, is_a(Proc)) { 'after_create callback' }
+    @factory.add_callback(:after_create) {}
+    @factory.attributes.should include('after_create callback')
+  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 raise an InvalidCallbackNameError when defining a callback with an invalid name" do
+    lambda{
+      @factory.add_callback(:invalid_callback_name) {}
+    }.should raise_error(FactoryGirl::InvalidCallbackNameError)
+  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
+  describe "after adding an attribute" do
+    before do
+      @attribute = "attribute"
+      @proxy     = "proxy"
 
-    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
+      stub(@attribute).name { :name }
+      stub(@attribute).add_to
+      stub(@proxy).set
+      stub(@proxy).result { 'result' }
+      stub(FactoryGirl::Attribute::Static).new { @attribute }
+      stub(FactoryGirl::Proxy::Build).new { @proxy }
 
-    it "should raise for a self referencing association" do
-      factory = Factory.new(:post)
-      lambda {
-        factory.association(:parent, :factory => :post)
-      }.should raise_error(Factory::AssociationDefinitionError)
+      @factory.define_attribute(@attribute)
     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)
+    it "should create the right proxy using the build class when running" do
+      mock(FactoryGirl::Proxy::Build).new(@factory.build_class) { @proxy }
+      @factory.run(FactoryGirl::Proxy::Build, {})
     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'
+    it "should add the attribute to the proxy when running" do
+      mock(@attribute).add_to(@proxy)
+      @factory.run(FactoryGirl::Proxy::Build, {})
     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)
+    it "should return the result from the proxy when running" do
+      mock(@proxy).result() { 'result' }
+      @factory.run(FactoryGirl::Proxy::Build, {}).should == 'result'
     end
+  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
+  it "should return associations" do
+    factory = FactoryGirl::Factory.new(:post)
+    factory.define_attribute(FactoryGirl::Attribute::Association.new(:author, :author, {}))
+    factory.define_attribute(FactoryGirl::Attribute::Association.new(:editor, :editor, {}))
+    factory.associations.each do |association|
+      association.should be_a(FactoryGirl::Attribute::Association)
     end
+    factory.associations.size.should == 2
+  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 raise for a self referencing association" do
+    factory = FactoryGirl::Factory.new(:post)
+    lambda {
+      factory.define_attribute(FactoryGirl::Attribute::Association.new(:parent, :post, {}))
+    }.should raise_error(FactoryGirl::AssociationDefinitionError)
+  end
 
-    it "should guess the build class from the factory name" do
-      @factory.build_class.should == User
+  describe "when overriding generated attributes with a hash" do
+    before do
+      @name  = :name
+      @value = 'The price is right!'
+      @hash  = { @name => @value }
     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
+    it "should return the overridden value in the generated attributes" do
+      attr = FactoryGirl::Attribute::Static.new(@name, 'The price is wrong, Bob!')
+      @factory.define_attribute(attr)
+      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      result[@name].should == @value
     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
+    it "should not call a lazy attribute block for an overridden attribute" do
+      attr = FactoryGirl::Attribute::Dynamic.new(@name, lambda { flunk })
+      @factory.define_attribute(attr)
+      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
     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
+    it "should override a symbol parameter with a string parameter" do
+      attr = FactoryGirl::Attribute::Static.new(@name, 'The price is wrong, Bob!')
+      @factory.define_attribute(attr)
+      @hash = { @name.to_s => @value }
+      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      result[@name].should == @value
     end
   end
 
-  describe "a factory with a name ending in s" do
+  describe "overriding an attribute with an alias" do
     before do
-      @name    = :business
-      @class   = Business
-      @factory = Factory.new(@name)
+      @factory.define_attribute(FactoryGirl::Attribute::Static.new(:test, 'original'))
+      Factory.alias(/(.*)_alias/, '\1')
+      @result = @factory.run(FactoryGirl::Proxy::AttributesFor,
+                             :test_alias => 'new')
     end
 
-    it "should have a factory name" do
-      @factory.factory_name.should == @name
+    it "should use the passed in value for the alias" do
+      @result[:test_alias].should == 'new'
     end
 
-    it "should have a build class" do
-      @factory.build_class.should == @class
+    it "should discard the predefined value for the attribute" do
+      @result[:test].should be_nil
     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
+  it "should guess the build class from the factory name" do
+    @factory.build_class.should == User
   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
+  it "should create a new factory using the class of the parent" do
+    child = FactoryGirl::Factory.new(:child)
+    child.inherit_from(@factory)
+    child.build_class.should == @factory.build_class
   end
 
-  describe "a factory for namespaced class" do
-    before do
-      Factory.factories = {}
-      @name  = :settings
-      @class = Admin::Settings
-    end
-
-    it "should build namespaced class passed by string" do
-      factory = Factory.define(@name.to_s, :class => @class.name) {}
-      factory.build_class.should == @class
-    end
-
-    it "should build Admin::Settings class from Admin::Settings string" do
-      factory = Factory.define(@name.to_s, :class => 'admin/settings') {}
-      factory.build_class.should == @class
-    end
+  it "should create a new factory while overriding the parent class" do
+    child = FactoryGirl::Factory.new(:child, :class => String)
+    child.inherit_from(@factory)
+    child.build_class.should == String
   end
 
-  describe "after defining a factory" do
+  describe "given a parent with attributes" 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'
+      @parent_attr = :name
+      @factory.define_attribute(FactoryGirl::Attribute::Static.new(@parent_attr, 'value'))
     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'
+    it "should create a new factory with attributes of the parent" do
+      child = FactoryGirl::Factory.new(:child)
+      child.inherit_from(@factory)
+      child.attributes.size.should == 1
+      child.attributes.first.name.should == @parent_attr
     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'
+    it "should allow a child to define additional attributes" do
+      child = FactoryGirl::Factory.new(:child)
+      child.define_attribute(FactoryGirl::Attribute::Static.new(:email, 'value'))
+      child.inherit_from(@factory)
+      child.attributes.size.should == 2
     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'
+    it "should allow to override parent attributes" do
+      child = FactoryGirl::Factory.new(:child)
+      @child_attr = FactoryGirl::Attribute::Static.new(@parent_attr, 'value')
+      child.define_attribute(@child_attr)
+      child.inherit_from(@factory)
+      child.attributes.size.should == 1
+      child.attributes.first.should == @child_attr
     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
+    it "should allow to use parent attributes in defining additional attributes" do
+      User.class_eval { attr_accessor :name, :email }
 
-    [: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
+      child = FactoryGirl::Factory.new(:child)
+      @child_attr = FactoryGirl::Attribute::Dynamic.new(:email, lambda {|u| "#{u.name}@example.com"})
+      child.define_attribute(@child_attr)
+      child.inherit_from(@factory)
+      child.attributes.size.should == 2
 
-      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
+      result = child.run(FactoryGirl::Proxy::Build, {})
+      result.email.should == 'value@example.com'
     end
   end
 
-  describe 'defining a factory with a parent parameter' do
-    before do
-      @parent = Factory.define :object do |f|
-        f.name  'Name'
-      end
-    end
+  it "inherit all callbacks" do
+    @factory.add_callback(:after_stub) { |object| object.name = 'Stubby' }
+    child = FactoryGirl::Factory.new(:child)
+    child.inherit_from(@factory)
+    child.attributes.last.should be_kind_of(FactoryGirl::Attribute::Callback)
+  end
+end
 
-    after { Factory.factories.clear }
+describe FactoryGirl::Factory, "when defined with a custom class" do
+  before do
+    @class   = Float
+    @factory = FactoryGirl::Factory.new(:author, :class => @class)
+  end
 
-    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 use the specified class as the build class" do
+    @factory.build_class.should == @class
+  end
+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
+describe FactoryGirl::Factory, "when defined with a class instead of a name" do
+  before do
+    @class   = ArgumentError
+    @name    = :argument_error
+    @factory = FactoryGirl::Factory.new(@class)
+  end
 
-    it "should create a new factory while overriding the parent class" do
-      class Other; end
+  it "should guess the name from the class" do
+    @factory.name.should == @name
+  end
 
-      child = Factory.define(:child, :parent => :object, :class => Other) {}
-      child.build_class.should == Other
-    end
+  it "should use the class as the build class" do
+    @factory.build_class.should == @class
+  end
+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
+describe FactoryGirl::Factory, "when defined with a custom class name" do
+  before do
+    @class   = ArgumentError
+    @factory = FactoryGirl::Factory.new(:author, :class => :argument_error)
+  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 use the specified class as the build class" do
+    @factory.build_class.should == @class
+  end
+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
+describe FactoryGirl::Factory, "with a name ending in s" do
+  include DefinesConstants
 
-    it "should allow to use parent attributes in defining additional attributes" do
-      User.class_eval { attr_accessor :name, :email }
+  before do
+    define_constant('Business')
+    @name    = :business
+    @class   = Business
+    @factory = FactoryGirl::Factory.new(@name)
+  end
 
-      parent = Factory.define(:parent, :class => User) do |f|
-        f.name 'value'
-      end
+  it "should have a factory name" do
+    @factory.name.should == @name
+  end
 
-      child = Factory.new(:child)
-      child.add_attribute(:email) {|u| "#{u.name}@example.com" }
-      child.inherit_from(parent)
-      child.attributes.size.should == 2
+  it "should have a build class" do
+    @factory.build_class.should == @class
+  end
+end
 
-      result = child.run(Factory::Proxy::Build, {})
-      result.email.should == 'value@example.com'
-    end
+describe FactoryGirl::Factory, "with a string for a name" do
+  before do
+    @name    = :string
+    @factory = FactoryGirl::Factory.new(@name.to_s) {}
+  end
 
-    it "inherit all callbacks" do
-      Factory.define(:child, :parent => :object) do |f|
-        f.after_stub {|o| o.name = 'Stubby' }
-      end
+  it "should convert the string to a symbol" do
+    @factory.name.should == @name
+  end
+end
 
-      grandchild = Factory.define(:grandchild, :parent => :child) do |f|
-        f.after_stub {|o| o.name = "#{o.name} McStubby" }
-      end
+describe FactoryGirl::Factory, "registered with a string name" do
+  before do
+    @name    = :string
+    @factory = FactoryGirl::Factory.new(@name)
+    FactoryGirl.register_factory(@factory)
+  end
 
-      grandchild.attributes.size.should == 3
-      grandchild.attributes[1].should be_kind_of(Factory::Attribute::Callback)
-      grandchild.attributes[2].should be_kind_of(Factory::Attribute::Callback)
-    end
+  it "should store the factory using a symbol" do
+    FactoryGirl.factories[@name].should == @factory
   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
+describe FactoryGirl::Factory, "registered with a custom name" do
+  before do
+    @actual_name = :string
+    @custom_name = :words
+    @factory = FactoryGirl::Factory.new(@actual_name)
 
-    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
+    FactoryGirl.register_factory(@factory, :as => @custom_name)
+  end
 
-    describe 'defining a child factory without setting default strategy' do
-      before do
-        @child = Factory.define(:child_object, :parent => :object) {}
-      end
+  it "finds the factory using the custom name" do
+    FactoryGirl.factory_by_name(@custom_name).should == @factory
+  end
+end
 
-      it "should inherit default strategy from its parent" do
-        @child.default_strategy.should == :stub
-      end
-    end
+describe FactoryGirl::Factory, "for namespaced class" do
+  include DefinesConstants
 
-    describe 'defining a child factory with a default strategy' do
-      before do
-        @child2 = Factory.define(:child_object2, :parent => :object, :default_strategy => :build) {}
-      end
+  before do
+    define_constant('Admin')
+    define_constant('Admin::Settings')
 
-      it "should not inherit default strategy from parent" do
-        @child2.default_strategy.should == :build
-      end
-    end
+    @name  = :settings
+    @class = Admin::Settings
   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
-      end
-    end
+  it "should build namespaced class passed by string" do
+    factory = FactoryGirl::Factory.new(@name.to_s, :class => @class.name)
+    factory.build_class.should == @class
+  end
 
-    after do
-      Dir.chdir(@pwd)
-      FileUtils.rm_rf(@tmp_dir)
-    end
+  it "should build Admin::Settings class from Admin::Settings string" do
+    factory = FactoryGirl::Factory.new(@name.to_s, :class => 'admin/settings')
+    factory.build_class.should == @class
   end
+end
 
-  def require_definitions_from(file)
-    simple_matcher do |given, matcher|
-      full_path = File.expand_path(file)
-      has_received = have_received.method_missing(:require, full_path)
-      result = has_received.matches?(given)
-      matcher.description = "require definitions from #{file}"
-      matcher.failure_message = has_received.failure_message
-      result
-    end
+describe FactoryGirl::Factory do
+  include DefinesConstants
+
+  before do
+    define_constant('User')
+    define_constant('Admin', User)
   end
 
-  share_examples_for "finds definitions" do
-    before do
-      stub(Factory).require
-      Factory.find_definitions
-    end
-    subject { Factory }
+  it "should raise an ArgumentError when trying to use a non-existent strategy" do
+    lambda {
+      FactoryGirl::Factory.new(:object, :default_strategy => :nonexistent) {}
+    }.should raise_error(ArgumentError)
   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') }
+  it "should create a new factory with a specified default strategy" do
+    factory = FactoryGirl::Factory.new(:object, :default_strategy => :stub)
+    factory.default_strategy.should == :stub
   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") }
+  describe 'defining a child factory without setting default strategy' do
+    before do
+      @parent = FactoryGirl::Factory.new(:object, :default_strategy => :stub)
+      @child = FactoryGirl::Factory.new(:child_object)
+      @child.inherit_from(@parent)
     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") }
+    it "should inherit default strategy from its parent" do
+      @child.default_strategy.should == :stub
     end
+  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") }
+  describe 'defining a child factory with a default strategy' do
+    before do
+      @parent = FactoryGirl::Factory.new(:object, :default_strategy => :stub)
+      @child = FactoryGirl::Factory.new(:child_object2, :default_strategy => :build)
+      @child.inherit_from(@parent)
     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") }
+    it "should override the default strategy from parent" do
+      @child.default_strategy.should == :build
     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
+
+describe FactoryGirl::Factory, "with an underscore in the name" do
+  subject { FactoryGirl::Factory.new("happy_users") }
 
+  it "has a human name" do
+    subject.human_name.should == 'happy users'
+  end
 end
+