factory_girl 2.1.0 → 2.1.2

data/spec/acceptance/callbacks_spec.rb

@@ -12,7 +12,8 @@ describe "callbacks" do
       end
 
       factory :user_with_inherited_callbacks, :parent => :user_with_callbacks do
-        after_stub { |user| user.last_name = 'Double-Stubby' }
+        after_stub  { |user| user.last_name  = 'Double-Stubby' }
+        after_build { |user| user.first_name = 'Child-Buildy' }
       end
     end
   end
@@ -38,4 +39,9 @@ describe "callbacks" do
     user.first_name.should == 'Stubby'
     user.last_name.should == 'Double-Stubby'
   end
+
+  it "runs child callback after parent callback" do
+    user = FactoryGirl.build(:user_with_inherited_callbacks)
+    user.first_name.should == 'Child-Buildy'
+  end
 end

data/spec/acceptance/modify_inherited_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe "modifying inherited factories with traits" do
+  before do
+    define_model('User', :gender => :string, :admin => :boolean, :age => :integer)
+    FactoryGirl.define do
+      factory :user do
+        trait(:female) { gender "Female" }
+        trait(:male)   { gender "Male" }
+
+        trait(:young_admin) do
+          admin true
+          age   17
+        end
+
+        female
+        young_admin
+
+        factory :female_user do
+          gender "Female"
+          age 25
+        end
+
+        factory :male_user do
+          gender "Male"
+        end
+      end
+    end
+  end
+
+  it "returns the correct value for overridden attributes from traits" do
+    Factory.build(:male_user).gender.should == "Male"
+  end
+
+  it "returns the correct value for overridden attributes from traits defining multiple attributes" do
+    Factory.build(:female_user).gender.should == "Female"
+    Factory.build(:female_user).age.should == 25
+    Factory.build(:female_user).admin.should == true
+  end
+
+  it "allows modification of attributes created via traits" do
+    FactoryGirl.modify do
+      factory :male_user do
+        age 20
+      end
+    end
+
+    Factory.build(:male_user).gender.should == "Male"
+    Factory.build(:male_user).age.should == 20
+    Factory.build(:male_user).admin.should == true
+  end
+end

data/spec/acceptance/syntax/vintage_spec.rb

@@ -46,13 +46,7 @@ describe "vintage syntax" do
   end
 end
 
-describe Factory, "given a parent factory" do
-  before do
-    @parent = FactoryGirl::Factory.new(:object)
-    @parent.define_attribute(FactoryGirl::Attribute::Static.new(:name, 'value'))
-    FactoryGirl.register_factory(@parent)
-  end
-
+describe Factory, "referencing a nonexistent factory as a parent" do
   it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
     lambda {
       Factory.define(:child, :parent => :nonexsitent) {}
@@ -220,3 +214,21 @@ describe "an attribute generated by an in-line sequence" do
   end
 end
 
+
+describe "a factory with a parent" do
+  before do
+    define_model("User", :username => :string)
+
+    Factory.define(:user) do |factory|
+      factory.username "awesome_username"
+    end
+
+    Factory.define(:boring_user, :parent => :user) do |factory|
+      factory.username "boring_username"
+    end
+  end
+
+  it "supports defining parents" do
+    Factory.build(:boring_user).username.should == "boring_username"
+  end
+end

data/spec/factory_girl/attribute_list_spec.rb

@@ -47,7 +47,7 @@ end
 
 describe FactoryGirl::AttributeList, "#attribute_defined?" do
   let(:static_attribute)                    { FactoryGirl::Attribute::Static.new(:full_name, "value") }
-  let(:callback_attribute)                  { FactoryGirl::Attribute::Callback.new(:after_create, lambda { }) }
+  let(:callback_attribute)                  { FactoryGirl::Callback.new(:after_create, lambda { }) }
   let(:static_attribute_named_after_create) { FactoryGirl::Attribute::Static.new(:after_create, "funky!") }
 
   it "knows if an attribute has been defined" do
@@ -58,50 +58,17 @@ describe FactoryGirl::AttributeList, "#attribute_defined?" do
     subject.attribute_defined?(static_attribute.name).should == true
     subject.attribute_defined?(:undefined_attribute).should == false
   end
-
-  it "doesn't reference callbacks" do
-    subject.define_attribute(callback_attribute)
-
-    subject.attribute_defined?(:after_create).should == false
-
-    subject.define_attribute(static_attribute_named_after_create)
-    subject.attribute_defined?(:after_create).should == true
-  end
 end
 
 describe FactoryGirl::AttributeList, "#add_callback" do
   let(:proxy_class) { mock("klass") }
   let(:proxy) { FactoryGirl::Proxy.new(proxy_class) }
-  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" }
-
-    subject.first.name.should == :after_create
-
-    subject.first.add_to(proxy)
-    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
-        subject.add_callback(callback_name) { "great name!" }
-      end.to_not raise_error(FactoryGirl::InvalidCallbackNameError)
-    end
-  end
+    subject.add_callback(FactoryGirl::Callback.new(:after_create, lambda { "Called after_create" }))
 
-  it "raises if an invalid callback name is assigned" do
-    invalid_callback_names.each do |callback_name|
-      expect do
-        subject.add_callback(callback_name) { "great name!" }
-      end.to raise_error(FactoryGirl::InvalidCallbackNameError, "#{callback_name} is not a valid callback name. Valid callback names are [:after_build, :after_create, :after_stub]")
-    end
+    subject.callbacks.first.name.should == :after_create
+    subject.callbacks.first.run(nil, nil).should == "Called after_create"
   end
 end
 
@@ -111,22 +78,28 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
   let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, lambda {|model| "#{model.full_name}@example.com" }) }
   let(:login_attribute)     { FactoryGirl::Attribute::Dynamic.new(:login, lambda {|model| "username-#{model.full_name}" }) }
 
+  def list(*attributes)
+    FactoryGirl::AttributeList.new.tap do |list|
+      attributes.each { |attribute| list.define_attribute(attribute) }
+    end
+  end
+
   it "prepends applied attributes" do
     subject.define_attribute(full_name_attribute)
-    subject.apply_attributes([city_attribute])
+    subject.apply_attributes(list(city_attribute))
     subject.to_a.should == [city_attribute, full_name_attribute]
   end
 
   it "moves non-static attributes to the end of the list" do
     subject.define_attribute(full_name_attribute)
-    subject.apply_attributes([city_attribute, email_attribute])
+    subject.apply_attributes(list(city_attribute, email_attribute))
     subject.to_a.should == [city_attribute, full_name_attribute, email_attribute]
   end
 
   it "maintains order of non-static attributes" do
     subject.define_attribute(full_name_attribute)
     subject.define_attribute(login_attribute)
-    subject.apply_attributes([city_attribute, email_attribute])
+    subject.apply_attributes(list(city_attribute, email_attribute))
     subject.to_a.should == [city_attribute, full_name_attribute, email_attribute, login_attribute]
   end
 
@@ -134,7 +107,7 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
     subject.define_attribute(full_name_attribute)
     attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin")
 
-    subject.apply_attributes([attribute_with_same_name])
+    subject.apply_attributes(list(attribute_with_same_name))
     subject.to_a.should == [full_name_attribute]
   end
 
@@ -143,20 +116,20 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
 
     it "prepends applied attributes" do
       subject.define_attribute(full_name_attribute)
-      subject.apply_attributes([city_attribute])
+      subject.apply_attributes(list(city_attribute))
       subject.to_a.should == [city_attribute, full_name_attribute]
     end
 
     it "moves non-static attributes to the end of the list" do
       subject.define_attribute(full_name_attribute)
-      subject.apply_attributes([city_attribute, email_attribute])
+      subject.apply_attributes(list(city_attribute, email_attribute))
       subject.to_a.should == [city_attribute, full_name_attribute, email_attribute]
     end
 
     it "maintains order of non-static attributes" do
       subject.define_attribute(full_name_attribute)
       subject.define_attribute(login_attribute)
-      subject.apply_attributes([city_attribute, email_attribute])
+      subject.apply_attributes(list(city_attribute, email_attribute))
       subject.to_a.should == [city_attribute, full_name_attribute, email_attribute, login_attribute]
     end
 
@@ -164,7 +137,7 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
       subject.define_attribute(full_name_attribute)
       attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin")
 
-      subject.apply_attributes([attribute_with_same_name])
+      subject.apply_attributes(list(attribute_with_same_name))
       subject.to_a.should == [attribute_with_same_name]
     end
   end

data/spec/factory_girl/callback_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe FactoryGirl::Callback do
+  it "has a name" do
+    FactoryGirl::Callback.new(:after_create, lambda {}).name.should == :after_create
+  end
+
+  it "converts strings to symbols" do
+    FactoryGirl::Callback.new("after_create", lambda {}).name.should == :after_create
+  end
+
+  it "runs its block with no parameters" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { ran_with = [] }).run(:one, :two)
+    ran_with.should == []
+  end
+
+  it "runs its block with one parameter" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { |one| ran_with = [one] }).run(:one, :two)
+    ran_with.should == [:one]
+  end
+
+  it "runs its block with two parameters" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { |one, two| ran_with = [one, two] }).run(:one, :two)
+    ran_with.should == [:one, :two]
+  end
+
+  it "allows valid callback names to be assigned" do
+    FactoryGirl::Callback::VALID_NAMES.each do |callback_name|
+      expect { FactoryGirl::Callback.new(callback_name, lambda {}) }.
+        to_not raise_error(FactoryGirl::InvalidCallbackNameError)
+    end
+  end
+
+  it "raises if an invalid callback name is assigned" do
+    expect { FactoryGirl::Callback.new(:magic_fairies, lambda {}) }.
+      to raise_error(FactoryGirl::InvalidCallbackNameError, /magic_fairies is not a valid callback name/)
+  end
+end

data/spec/factory_girl/{attribute → declaration}/implicit_spec.rb

@@ -1,24 +1,27 @@
 require 'spec_helper'
 
-describe FactoryGirl::Attribute::Implicit do
-  let(:name)  { :author }
-  let(:proxy) { stub("proxy") }
-  subject     { FactoryGirl::Attribute::Implicit.new(name) }
-
-  its(:name) { should == name }
+describe FactoryGirl::Declaration::Implicit do
+  let(:name)      { :author }
+  let(:proxy)     { stub("proxy") }
+  subject         { FactoryGirl::Declaration::Implicit.new(name) }
+  let(:attribute) { subject.to_attributes.first }
 
   context "with a known factory" do
     before do
       FactoryGirl.factories.stubs(:registered? => true)
     end
 
-    it { should be_association }
+    it "generates an association" do
+      attribute.should be_association
+    end
 
-    its(:factory) { should == name }
+    it "generates an association with the correct factory" do
+      attribute.factory.should == name
+    end
 
     it "associates the factory" do
       proxy.stubs(:associate)
-      subject.add_to(proxy)
+      attribute.add_to(proxy)
       proxy.should have_received(:associate).with(name, name, {})
     end
   end
@@ -27,11 +30,13 @@ describe FactoryGirl::Attribute::Implicit do
     let(:sequence) { FactoryGirl::Sequence.new(name, 1) { "magic" } }
     before         { FactoryGirl.register_sequence(sequence) }
 
-    it { should_not be_association }
+    it "doesn't generate an association" do
+      attribute.should_not be_association
+    end
 
     it "generates the sequence" do
       proxy.stubs(:set)
-      subject.add_to(proxy)
+      attribute.add_to(proxy)
       proxy.should have_received(:set).with(name, "magic")
     end
   end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -4,14 +4,18 @@ describe FactoryGirl::DefinitionProxy do
   let(:factory) { FactoryGirl::Factory.new(:object) }
   subject { FactoryGirl::DefinitionProxy.new(factory) }
 
+  def attributes
+    factory.attributes
+  end
+
   it "should add a static attribute for type" do
     subject.type 'value'
-    factory.attributes.last.should be_kind_of(FactoryGirl::Attribute::Static)
+    attributes.to_a.last.should be_kind_of(FactoryGirl::Attribute::Static)
   end
 
   it "should add a static attribute for id" do
     subject.id 'value'
-    factory.attributes.last.should be_kind_of(FactoryGirl::Attribute::Static)
+    attributes.to_a.last.should be_kind_of(FactoryGirl::Attribute::Static)
   end
 
   it "should add a static attribute when an attribute is defined with a value" do
@@ -19,6 +23,7 @@ describe FactoryGirl::DefinitionProxy do
     FactoryGirl::Attribute::Static.stubs(:new => attribute)
     factory.stubs(:define_attribute)
     subject.add_attribute(:name, 'value')
+    factory.compile
     factory.should have_received(:define_attribute).with(attribute)
     FactoryGirl::Attribute::Static.should have_received(:new).with(:name, "value")
   end
@@ -29,6 +34,7 @@ describe FactoryGirl::DefinitionProxy do
     FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
     factory.stubs(:define_attribute)
     subject.add_attribute(:name, &block)
+    factory.compile
     FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, block)
     factory.should have_received(:define_attribute).with(attribute)
   end
@@ -41,7 +47,7 @@ describe FactoryGirl::DefinitionProxy do
 
   it "should add an attribute with a built-in private method" do
     subject.instance_eval { sleep(0.1) }
-    factory.attributes.map { |attribute| attribute.name }.should == [:sleep]
+    attributes.map { |attribute| attribute.name }.should == [:sleep]
   end
 
   describe "child factories" do
@@ -67,15 +73,6 @@ describe FactoryGirl::DefinitionProxy do
       FactoryGirl::Sequence.should have_received(:new).with(:name, "A")
     end
   end
-
-  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
@@ -126,12 +123,14 @@ describe FactoryGirl::DefinitionProxy, "adding attributes" do
 
     it "creates a dynamic attribute" do
       subject.add_attribute(attribute_name, &block)
+      factory.compile
       FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
       factory.should have_received(:define_attribute).with(attribute)
     end
 
     it "creates a dynamic attribute without the method being defined" do
       subject.send(attribute_name, &block)
+      factory.compile
       FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
       factory.should have_received(:define_attribute).with(attribute)
     end
@@ -142,12 +141,14 @@ describe FactoryGirl::DefinitionProxy, "adding attributes" do
 
     it "creates a static attribute" do
       subject.add_attribute(attribute_name, attribute_value)
+      factory.compile
       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)
+      factory.compile
       FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
       factory.should have_received(:define_attribute).with(attribute)
     end
@@ -179,6 +180,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute with the factory name" do
       subject.association(association_name, options)
+      factory.compile
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
@@ -186,6 +188,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute when the association is called implicitly" do
       subject.send(association_name, options)
+      factory.compile
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
@@ -197,6 +200,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute with the association name" do
       subject.association(association_name, options)
+      factory.compile
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, association_name, options)