factory_girl 2.0.4 → 2.0.5

data/spec/factory_girl/attribute_list_spec.rb

@@ -12,6 +12,11 @@ describe FactoryGirl::AttributeList, "#define_attribute" do
     subject.to_a.should == [static_attribute, dynamic_attribute]
   end
 
+  it "returns the attribute" do
+    subject.define_attribute(static_attribute).should == static_attribute
+    subject.define_attribute(dynamic_attribute).should == dynamic_attribute
+  end
+
   it "raises if an attribute has already been defined" do
     expect {
       2.times { subject.define_attribute(static_attribute) }
@@ -49,7 +54,6 @@ describe FactoryGirl::AttributeList, "#add_callback" do
   let(:valid_callback_names) { [:after_create, :after_build, :after_stub] }
   let(:invalid_callback_names) { [:before_create, :before_build, :bogus] }
 
-
   it "allows for defining adding a callback" do
     subject.add_callback(:after_create) { "Called after_create" }
 
@@ -59,6 +63,10 @@ describe FactoryGirl::AttributeList, "#add_callback" do
     proxy.callbacks[:after_create].first.call.should == "Called after_create"
   end
 
+  it "returns the callback" do
+    subject.add_callback(:after_create) { "Called after_create" }.should be_a(FactoryGirl::Attribute::Callback)
+  end
+
   it "allows valid callback names to be assigned" do
     valid_callback_names.each do |callback_name|
       expect do

data/spec/factory_girl/attribute_spec.rb

@@ -1,43 +1,32 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute do
-  before do
-    @name  = :user
-    @attr  = FactoryGirl::Attribute.new(@name)
-  end
-
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  let(:name)  { "user" }
+  let(:proxy) { stub("proxy") }
+  subject     { FactoryGirl::Attribute.new(name) }
 
-  it "isn't an association" do
-    @attr.should_not be_association
-  end
+  its(:name) { should == name.to_sym }
+  it { should_not be_association }
 
-  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
+  it "doesn't set any attributes on a proxy when added" do
+    proxy.stubs(:set)
+    subject.add_to(proxy)
+    proxy.should have_received(:set).never
   end
 
-  it "should raise an error when defining an attribute writer" do
+  it "raises an error when defining an attribute writer" do
     error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
-    lambda {
+    expect {
       FactoryGirl::Attribute.new('test=')
-    }.should raise_error(FactoryGirl::AttributeDefinitionError, error_message)
-  end
-
-  it "should convert names to symbols" do
-    FactoryGirl::Attribute.new('name').name.should == :name
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, error_message)
   end
 
-  it "should return nil when is compared with a non-attribute object" do
-    (@attr <=> "foo").should == nil
+  it "returns nil when compared to a non-attribute" do
+    (subject <=> "foo").should be_nil
   end
 
-  it "should use priority to perform comparisons" do
-    attr2 = FactoryGirl::Attribute.new('name')
-    (@attr <=> attr2).should == 0
+  it "uses priority to perform comparisons" do
+    second_attribute = FactoryGirl::Attribute.new('name')
+    (subject <=> second_attribute).should be_zero
   end
 end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -15,20 +15,22 @@ describe FactoryGirl::DefinitionProxy do
   end
 
   it "should add a static attribute when an attribute is defined with a value" do
-    attribute = 'attribute'
-    stub(attribute).name { :name }
-    mock(FactoryGirl::Attribute::Static).new(:name, 'value') { attribute }
-    mock(factory).define_attribute(attribute)
+    attribute = stub('attribute', :name => :name)
+    FactoryGirl::Attribute::Static.stubs(:new => attribute)
+    factory.stubs(:define_attribute)
     subject.add_attribute(:name, 'value')
+    factory.should have_received(:define_attribute).with(attribute)
+    FactoryGirl::Attribute::Static.should have_received(:new).with(:name, "value")
   end
 
   it "should add a dynamic attribute when an attribute is defined with a block" do
-    attribute = 'attribute'
-    stub(attribute).name { :name }
+    attribute = stub('attribute', :name => :name)
     block     = lambda {}
-    mock(FactoryGirl::Attribute::Dynamic).new(:name, block) { attribute }
-    mock(factory).define_attribute(attribute)
+    FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
+    factory.stubs(:define_attribute)
     subject.add_attribute(:name, &block)
+    FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, block)
+    factory.should have_received(:define_attribute).with(attribute)
   end
 
   it "should raise for an attribute with a value and a block" do
@@ -54,103 +56,150 @@ describe FactoryGirl::DefinitionProxy do
 
   describe "adding an attribute using a in-line sequence" do
     it "should create the sequence" do
-      mock(FactoryGirl::Sequence).new(:name, 1)
+      FactoryGirl::Sequence.stubs(:new)
       subject.sequence(:name) {}
+      FactoryGirl::Sequence.should have_received(:new).with(:name, 1)
     end
 
     it "should create the sequence with a custom default value" do
-      mock(FactoryGirl::Sequence).new(:name, "A")
+      FactoryGirl::Sequence.stubs(:new)
       subject.sequence(:name, "A") {}
+      FactoryGirl::Sequence.should have_received(:new).with(:name, "A")
     end
+  end
 
-    it "should add a dynamic attribute" do
-      attribute = 'attribute'
-      stub(attribute).name { :name }
-      mock(FactoryGirl::Attribute::Dynamic).new(:name, is_a(Proc)) { attribute }
-      subject.sequence(:name) {}
-      factory.attributes.should include(attribute)
+  it "adds an implicit attribute when passed an undefined method without arguments or a block" do
+    factory.stubs(:define_attribute)
+    attribute = stub('attribute', :name => :name)
+    FactoryGirl::Attribute::Implicit.stubs(:new => attribute)
+    subject.send(:name)
+    FactoryGirl::Attribute::Implicit.should have_received(:new).with(:name, factory)
+    factory.should have_received(:define_attribute).with(attribute)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "with a factory mock" do
+  before do
+    define_class("FactoryMock") do
+      def add_callback(callback, &block)
+        [callback, block.call]
+      end
+
+      def to_create(&block)
+        block.call
+      end
     end
   end
 
-  it "should add a callback attribute when the after_build attribute is defined" do
-    mock(FactoryGirl::Attribute::Callback).new(:after_build, is_a(Proc)) { 'after_build callback' }
-    subject.after_build {}
-    factory.attributes.should include('after_build callback')
+  let(:factory_mock) { FactoryMock.new }
+  subject { FactoryGirl::DefinitionProxy.new(factory_mock) }
+
+  it "defines after_build callbacks" do
+    subject.after_build { "after_build value" }.should == [:after_build, "after_build value"]
+  end
+
+  it "defines after_create callbacks" do
+    subject.after_create { "after_create value" }.should == [:after_create, "after_create value"]
+  end
+
+  it "defines after_stub callbacks" do
+    subject.after_stub { "after_stub value" }.should == [:after_stub, "after_stub value"]
   end
 
-  it "should add a callback attribute when the after_create attribute is defined" do
-    mock(FactoryGirl::Attribute::Callback).new(:after_create, is_a(Proc)) { 'after_create callback' }
-    subject.after_create {}
-    factory.attributes.should include('after_create callback')
+  it "defines to_create" do
+    subject.to_create { "to_create value" }.should == "to_create value"
   end
+end
+
+describe FactoryGirl::DefinitionProxy, "adding attributes" do
+  let(:factory)         { FactoryGirl::Factory.new(:object) }
+  subject               { FactoryGirl::DefinitionProxy.new(factory) }
+  let(:attribute)       { stub("created attribute") }
+  let(:block)           { lambda { } }
+  let(:attribute_name)  { :full_name }
+  let(:attribute_value) { "passed value" }
+
+  before { factory.stubs(:define_attribute) }
+
+  context "when a block is passed" do
+    before { FactoryGirl::Attribute::Dynamic.stubs(:new => attribute) }
+
+    it "creates a dynamic attribute" do
+      subject.add_attribute(attribute_name, &block)
+      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+      factory.should have_received(:define_attribute).with(attribute)
+    end
 
-  it "should add a callback attribute when the after_stub attribute is defined" do
-    mock(FactoryGirl::Attribute::Callback).new(:after_stub, is_a(Proc)) { 'after_stub callback' }
-    subject.after_stub {}
-    factory.attributes.should include('after_stub callback')
+    it "creates a dynamic attribute without the method being defined" do
+      subject.send(attribute_name, &block)
+      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+      factory.should have_received(:define_attribute).with(attribute)
+    end
   end
 
-  it "should add an association without a factory name or overrides" do
-    name = :user
-    attr = 'attribute'
-    stub(attr).name { name }
-    mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
-    subject.association(name)
-    factory.attributes.should include(attr)
+  context "when a value is passed" do
+    before { FactoryGirl::Attribute::Static.stubs(:new => attribute) }
+
+    it "creates a static attribute" do
+      subject.add_attribute(attribute_name, attribute_value)
+      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+      factory.should have_received(:define_attribute).with(attribute)
+    end
+
+    it "creates a static attribute without the method being defined" do
+      subject.send(attribute_name, attribute_value)
+      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+      factory.should have_received(:define_attribute).with(attribute)
+    end
   end
 
-  it "should add an association with overrides" do
-    name      = :user
-    attr      = 'attribute'
-    overrides = { :first_name => 'Ben' }
-    stub(attr).name { name }
-    mock(FactoryGirl::Attribute::Association).new(name, name, overrides) { attr }
-    subject.association(name, overrides)
-    factory.attributes.should include(attr)
+  context "when a block and value are passed" do
+    it "raises an exception" do
+      expect do
+        subject.add_attribute(attribute_name, attribute_value) { "block" }
+      end.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
+    end
   end
+end
 
-  it "should add an attribute using the method name when passed an undefined method" do
-    attribute = 'attribute'
-    stub(attribute).name { :name }
-    mock(FactoryGirl::Attribute::Static).new(:name, 'value') { attribute }
-    subject.send(:name, 'value')
-    factory.attributes.should include(attribute)
+describe FactoryGirl::DefinitionProxy, "#association" do
+  let(:factory)          { FactoryGirl::Factory.new(:object) }
+  subject                { FactoryGirl::DefinitionProxy.new(factory) }
+  let(:attribute)        { stub("attribute") }
+  let(:association_name) { :author }
+  let(:factory_name)     { :user }
+
+  before do
+    FactoryGirl::Attribute::Association.stubs(:new => attribute)
+    factory.stubs(:define_attribute)
   end
 
-  it "adds an attribute using when passed an undefined method and block" do
-    attribute = 'attribute'
-    stub(attribute).name { :name }
-    block = lambda {}
-    mock(FactoryGirl::Attribute::Dynamic).new(:name, block) { attribute }
-    subject.send(:name, &block)
-    factory.attributes.should include(attribute)
+  context "with a factory set in the hash" do
+    let(:options) { { :factory => factory_name, :name => "John Doe" } }
+
+    it "defines an association attribute with the factory name" do
+      subject.association(association_name, options)
+
+      factory.should have_received(:define_attribute).with(attribute)
+      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
+    end
+
+    it "defines an association attribute when the association is called implicitly" do
+      subject.send(association_name, options)
+
+      factory.should have_received(:define_attribute).with(attribute)
+      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
+    end
   end
 
-  it "adds an implicit attribute when passed an undefined method without arguments or a block" do
-    name = :user
-    attr = 'attribute'
-    stub(attr).name { name }
-    mock(FactoryGirl::Attribute::Implicit).new(name, factory) { attr }
-    subject.send(name)
-    factory.attributes.should include(attr)
-  end
-
-  it "adds an association when passed an undefined method with a hash including :factory key" do
-    name = :author
-    factory_name = :user
-    overrides = { :first_name => 'Ben' }
-    args = { :factory => factory_name }.merge(overrides)
-    attr = 'attribute'
-    stub(attr).name { name }
-    mock(FactoryGirl::Attribute::Association).new(name, factory_name, overrides) { attr }
-    subject.send(name, args)
-    factory.attributes.should include(attr)
-  end
-
-  it "delegates to_create" do
-    result = 'expected'
-    mock(factory).to_create { result }
-
-    subject.to_create.should == result
+  context "without a factory set in the hash" do
+    let(:options) { { :name => "Jane Doe" } }
+
+    it "defines an association attribute with the association name" do
+      subject.association(association_name, options)
+
+      factory.should have_received(:define_attribute).with(attribute)
+      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, association_name, options)
+    end
   end
 end

data/spec/factory_girl/deprecated_spec.rb

@@ -1,66 +1,45 @@
 require 'spec_helper'
 
 describe "accessing an undefined method on Factory that is defined on FactoryGirl" do
-  let(:method_name) { :aliases }
+  let(:method_name)  { :aliases }
   let(:return_value) { 'value' }
-  let(:args) { [1, 2, 3] }
+  let(:args)         { [1, 2, 3] }
 
   before do
-    stub($stderr).puts
-    stub(FactoryGirl, method_name).returns { return_value }
-
-    @result = Factory.send(method_name, *args)
+    FactoryGirl.stubs(method_name => return_value)
   end
 
+  subject { Factory.send(method_name, *args) }
+
   it "prints a deprecation warning" do
-    $stderr.should have_received.puts(anything)
+    $stderr.stubs(:puts)
+    subject
+    $stderr.should have_received(:puts).with(anything)
   end
 
   it "invokes that method on FactoryGirl" do
-    FactoryGirl.should have_received.method_missing(method_name, *args)
+    subject
+    FactoryGirl.should have_received(method_name).with(*args)
   end
 
   it "returns the value from the method on FactoryGirl" do
-    @result.should == return_value
+    subject.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)
+    expect { Factory.send(:magic_beans) }.to raise_error(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
+  subject { Factory::VERSION }
+  it      { should == FactoryGirl::VERSION }
 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")
+    expect { Factory::BOGUS }.to raise_error(NameError, /Factory::BOGUS/)
   end
 end
-

data/spec/factory_girl/factory_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe FactoryGirl::Factory do
-  include DefinesConstants
-
   before do
     @name    = :user
     @class   = define_class('User')
@@ -25,48 +23,16 @@ describe FactoryGirl::Factory do
     @factory.default_strategy.should == :create
   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(FactoryGirl::Attribute::Static).new { @attribute }
-      stub(FactoryGirl::Proxy::Build).new { @proxy }
-
-      @factory.define_attribute(@attribute)
-    end
-
-    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 add the attribute to the proxy when running" do
-      mock(@attribute).add_to(@proxy)
-      @factory.run(FactoryGirl::Proxy::Build, {})
-    end
-
-    it "should return the result from the proxy when running" do
-      mock(@proxy).result(nil) { 'result' }
-      @factory.run(FactoryGirl::Proxy::Build, {}).should == 'result'
-    end
-  end
-
   it "passes a custom creation block" do
-    proxy = 'proxy'
-    stub(FactoryGirl::Proxy::Build).new { proxy }
-    stub(proxy).result {}
+    proxy = stub("proxy", :result => nil)
+    FactoryGirl::Proxy::Build.stubs(:new => proxy)
     block = lambda {}
     factory = FactoryGirl::Factory.new(:object)
     factory.to_create(&block)
 
     factory.run(FactoryGirl::Proxy::Build, {})
 
-    proxy.should have_received.result(block)
+    proxy.should have_received(:result).with(block)
   end
 
   it "should return associations" do
@@ -202,169 +168,174 @@ describe FactoryGirl::Factory do
 end
 
 describe FactoryGirl::Factory, "when defined with a custom class" do
-  before do
-    @class   = Float
-    @factory = FactoryGirl::Factory.new(:author, :class => @class)
-  end
-
-  it "should use the specified class as the build class" do
-    @factory.build_class.should == @class
-  end
+  subject           { FactoryGirl::Factory.new(:author, :class => Float) }
+  its(:build_class) { should == Float }
 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
+  let(:factory_class) { ArgumentError }
+  let(:name)          { :argument_error }
 
-  it "should guess the name from the class" do
-    @factory.name.should == @name
-  end
+  subject { FactoryGirl::Factory.new(factory_class) }
 
-  it "should use the class as the build class" do
-    @factory.build_class.should == @class
-  end
+  its(:name)        { should == name }
+  its(:build_class) { should == factory_class }
 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 use the specified class as the build class" do
-    @factory.build_class.should == @class
-  end
+  subject           { FactoryGirl::Factory.new(:author, :class => :argument_error) }
+  its(:build_class) { should == ArgumentError }
 end
 
 describe FactoryGirl::Factory, "with a name ending in s" do
-  include DefinesConstants
-
-  before do
-    define_class('Business')
-    @name    = :business
-    @class   = Business
-    @factory = FactoryGirl::Factory.new(@name)
-  end
+  let(:name)           { :business }
+  let(:business_class) { Business }
 
-  it "should have a factory name" do
-    @factory.name.should == @name
-  end
+  before  { define_class('Business') }
+  subject { FactoryGirl::Factory.new(name) }
 
-  it "should have a build class" do
-    @factory.build_class.should == @class
-  end
+  its(:name)        { should == name }
+  its(:build_class) { should == business_class }
 end
 
 describe FactoryGirl::Factory, "with a string for a name" do
-  before do
-    @name    = :string
-    @factory = FactoryGirl::Factory.new(@name.to_s) {}
-  end
-
-  it "should convert the string to a symbol" do
-    @factory.name.should == @name
-  end
+  let(:name) { :string }
+  subject    { FactoryGirl::Factory.new(name.to_s) }
+  its(:name) { should == name }
 end
 
 describe FactoryGirl::Factory, "for namespaced class" do
-  include DefinesConstants
+  let(:name)           { :settings }
+  let(:settings_class) { Admin::Settings }
 
   before do
-    define_class('Admin')
-    define_class('Admin::Settings')
-
-    @name  = :settings
-    @class = Admin::Settings
+    define_class("Admin")
+    define_class("Admin::Settings")
   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
+  context "with a namespaced class with Namespace::Class syntax" do
+    subject { FactoryGirl::Factory.new(name, :class => "Admin::Settings") }
+
+    it "sets build_class correctly" do
+      subject.build_class.should == settings_class
+    end
   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
+  context "with a namespaced class with namespace/class syntax" do
+    subject { FactoryGirl::Factory.new(name, :class => "admin/settings") }
+
+    it "sets build_class correctly" do
+      subject.build_class.should == settings_class
+    end
   end
 end
 
 describe FactoryGirl::Factory do
-  include DefinesConstants
+  let(:factory_with_non_existent_strategy) do
+    FactoryGirl::Factory.new(:object, :default_strategy => :nonexistent) { }
+  end
+
+  let(:factory_with_stub_strategy) do
+    FactoryGirl::Factory.new(:object, :default_strategy => :stub)
+  end
+
+  let(:factory_without_strategy) do
+    FactoryGirl::Factory.new(:other_object)
+  end
+
+  let(:factory_with_build_strategy) do
+    FactoryGirl::Factory.new(:other_object, :default_strategy => :build)
+  end
 
   before do
-    define_class('User')
-    define_class('Admin', User)
+    define_class("User")
+    define_class("Admin", User)
   end
 
-  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)
+  it "raises an ArgumentError when trying to use a non-existent strategy" do
+    expect { factory_with_non_existent_strategy }.to raise_error(ArgumentError)
   end
 
-  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
+  it "creates a new factory with a specified default strategy" do
+    factory_with_stub_strategy.default_strategy.should == :stub
   end
 
-  describe 'defining a child factory without setting default strategy' do
+  describe "defining a child factory without setting default strategy" do
+    let(:parent) { factory_with_stub_strategy }
+    subject      { factory_without_strategy }
+
     before do
-      @parent = FactoryGirl::Factory.new(:object, :default_strategy => :stub)
-      @child = FactoryGirl::Factory.new(:child_object)
-      @child.inherit_from(@parent)
+      subject.inherit_from(parent)
     end
 
-    it "should inherit default strategy from its parent" do
-      @child.default_strategy.should == :stub
+    it "inherits default strategy from its parent" do
+      subject.default_strategy.should == :stub
     end
   end
 
-  describe 'defining a child factory with a default strategy' do
+  describe "defining a child factory with a default strategy" do
+    let(:parent) { factory_with_stub_strategy }
+    subject      { factory_with_build_strategy }
+
     before do
-      @parent = FactoryGirl::Factory.new(:object, :default_strategy => :stub)
-      @child = FactoryGirl::Factory.new(:child_object2, :default_strategy => :build)
-      @child.inherit_from(@parent)
+      subject.inherit_from(parent)
     end
 
-    it "should override the default strategy from parent" do
-      @child.default_strategy.should == :build
+    it "overrides the default strategy from parent" do
+      subject.default_strategy.should == :build
     end
   end
-
 end
 
 describe FactoryGirl::Factory, "human names" do
   context "factory name without underscores" do
-    subject           { FactoryGirl::Factory.new("user") }
+    subject           { FactoryGirl::Factory.new(:user) }
+    its(:names)       { should == [:user] }
     its(:human_names) { should == ["user"] }
   end
 
   context "factory name with underscores" do
-    subject           { FactoryGirl::Factory.new("happy_user") }
+    subject           { FactoryGirl::Factory.new(:happy_user) }
+    its(:names)       { should == [:happy_user] }
     its(:human_names) { should == ["happy user"] }
   end
 
   context "factory name with aliases" do
-    subject           { FactoryGirl::Factory.new("happy_user", :aliases => ["gleeful_user", "person"]) }
+    subject           { FactoryGirl::Factory.new(:happy_user, :aliases => [:gleeful_user, :person]) }
+    its(:names)       { should == [:happy_user, :gleeful_user, :person] }
     its(:human_names) { should == ["happy user", "gleeful user", "person"] }
   end
 end
 
-describe FactoryGirl::Factory, "with aliases" do
-  it "registers the aliases" do
-    name = :user
-    aliased_name = :guest
-    factory = FactoryGirl::Factory.new(:user, :aliases => [aliased_name])
-    factory.names.should =~ [name, aliased_name]
+describe FactoryGirl::Factory, "running a factory" do
+  subject             { FactoryGirl::Factory.new(:user) }
+  let(:attribute)     { stub("attribute", :name => :name, :ignored => false, :add_to => nil, :aliases_for? => true) }
+  let(:proxy)         { stub("proxy", :result => "result", :set => nil) }
+
+  before do
+    define_model("User", :name => :string)
+    FactoryGirl::Attribute::Static.stubs(:new => attribute)
+    FactoryGirl::Proxy::Build.stubs(:new => proxy)
+    FactoryGirl::AttributeList.stubs(:new => [attribute])
+  end
+
+  it "creates the right proxy using the build class when running" do
+    subject.run(FactoryGirl::Proxy::Build, {})
+    FactoryGirl::Proxy::Build.should have_received(:new).with(subject.build_class)
+  end
+
+  it "adds the attribute to the proxy when running" do
+    subject.run(FactoryGirl::Proxy::Build, {})
+    attribute.should have_received(:add_to).with(proxy)
+  end
+
+  it "returns the result from the proxy when running" do
+    subject.run(FactoryGirl::Proxy::Build, {}).should == "result"
+    proxy.should have_received(:result).with(nil)
   end
 
-  it "has human names" do
-    name = :user
-    aliased_name = :guest
-    factory = FactoryGirl::Factory.new(:user, :aliases => [aliased_name])
-    factory.human_names.should =~ [name.to_s, aliased_name.to_s]
+  it "sets overrides once on the factory" do
+    subject.run(FactoryGirl::Proxy::Build, { :name => "John Doe" })
+    proxy.should have_received(:set).once
   end
 end