factory_girl 3.2.0 → 3.3.0

data/spec/acceptance/modify_factories_spec.rb

@@ -12,7 +12,7 @@ describe "modifying factories" do
       factory :user do
         email
 
-        after_create do |user|
+        after(:create) do |user|
           user.login = user.name.upcase if user.name
         end
 
@@ -58,7 +58,7 @@ describe "modifying factories" do
       FactoryGirl.modify do
         factory :user do
           name "Great User"
-          after_create do |user|
+          after(:create) do |user|
             user.name = user.name.downcase
             user.login = nil
           end

data/spec/acceptance/parent_spec.rb

@@ -78,7 +78,7 @@ describe "nested factories with different parents" do
         end
 
         factory :uppercase_male_user, parent: :male_user do
-          after_build {|user| user.name = user.name.upcase }
+          after(:build) {|user| user.name = user.name.upcase }
         end
       end
     end

data/spec/acceptance/register_strategies_spec.rb

@@ -41,6 +41,14 @@ describe "register custom strategies" do
     FactoryGirl.build(:named_object).name.should == "Great"
     FactoryGirl.insert(:named_object).name.should == "Custom strategy"
   end
+
+  it "allows using the *_list method to build a list using a custom strategy" do
+    FactoryGirl.register_strategy(:insert, custom_strategy)
+
+    inserted_items = FactoryGirl.insert_list(:named_object, 2)
+    inserted_items.length.should == 2
+    inserted_items.map(&:name).should == ["Custom strategy", "Custom strategy"]
+  end
 end
 
 describe "including FactoryGirl::Syntax::Methods when custom strategies have been declared" do

data/spec/acceptance/syntax/vintage_spec.rb

@@ -89,28 +89,28 @@ describe "after defining a factory" do
     FactoryGirl.register_factory(@factory)
   end
 
-  it "uses Strategy::AttributesFor for Factory.attributes_for" do
+  it "uses the attributes_for strategy for Factory.attributes_for" do
     @factory.stubs(run: "result")
     Factory.attributes_for(@name, attr: 'value').should == 'result'
-    @factory.should have_received(:run).with(FactoryGirl::Strategy::AttributesFor, attr: 'value')
+    @factory.should have_received(:run).with(:attributes_for, attr: 'value')
   end
 
-  it "uses Strategy::Build for Factory.build" do
+  it "uses the build strategy for Factory.build" do
     @factory.stubs(run: "result")
     Factory.build(@name, attr: 'value').should == 'result'
-    @factory.should have_received(:run).with(FactoryGirl::Strategy::Build, attr: 'value')
+    @factory.should have_received(:run).with(:build, attr: 'value')
   end
 
-  it "uses Strategy::Create for Factory.create" do
+  it "uses the create strategy for Factory.create" do
     @factory.stubs(run: "result")
     Factory.create(@name, attr: 'value').should == 'result'
-    @factory.should have_received(:run).with(FactoryGirl::Strategy::Create, attr: 'value')
+    @factory.should have_received(:run).with(:create, attr: 'value')
   end
 
-  it "uses Strategy::Stub for Factory.stub" do
+  it "uses the build_stubbed strategy for Factory.stub" do
     @factory.stubs(run: "result")
     Factory.stub(@name, attr: 'value').should == 'result'
-    @factory.should have_received(:run).with(FactoryGirl::Strategy::Stub, attr: 'value')
+    @factory.should have_received(:run).with(:build_stubbed, attr: 'value')
   end
 
   [:build, :create, :attributes_for, :stub].each do |method|

data/spec/acceptance/traits_spec.rb

@@ -187,11 +187,11 @@ describe "traits with callbacks" do
         name "John"
 
         trait :great do
-          after_create {|user| user.name.upcase! }
+          after(:create) {|user| user.name.upcase! }
         end
 
         trait :awesome do
-          after_create {|user| user.name = "awesome" }
+          after(:create) {|user| user.name = "awesome" }
         end
 
         factory :caps_user, traits: [:great]
@@ -232,7 +232,7 @@ describe "traits added via strategy" do
         end
 
         trait :great do
-          after_create {|user| user.name.upcase! }
+          after(:create) {|user| user.name.upcase! }
         end
       end
     end
@@ -419,3 +419,145 @@ describe "making sure the factory is properly compiled the first time we want to
     user.role.should == 'admin'
   end
 end
+
+describe "traits with to_create" do
+  before do
+    define_model("User", name: :string)
+
+    FactoryGirl.define do
+      factory :user do
+        trait :with_to_create do
+          to_create {|instance| instance.name = "to_create" }
+        end
+
+        factory :sub_user do
+          to_create {|instance| instance.name = "sub" }
+
+          factory :child_user
+        end
+
+        factory :sub_user_with_trait do
+          with_to_create
+
+          factory :child_user_with_trait
+        end
+
+        factory :sub_user_with_trait_and_override do
+          with_to_create
+          to_create {|instance| instance.name = "sub with trait and override" }
+
+          factory :child_user_with_trait_and_override
+        end
+      end
+    end
+  end
+
+  it "can apply to_create from traits" do
+    FactoryGirl.create(:user, :with_to_create).name.should == "to_create"
+  end
+
+  it "can apply to_create from the definition" do
+    FactoryGirl.create(:sub_user).name.should == "sub"
+    FactoryGirl.create(:child_user).name.should == "sub"
+  end
+
+  it "gives additional traits higher priority than to_create from the definition" do
+    FactoryGirl.create(:sub_user, :with_to_create).name.should == "to_create"
+    FactoryGirl.create(:child_user, :with_to_create).name.should == "to_create"
+  end
+
+  it "gives base traits normal priority" do
+    FactoryGirl.create(:sub_user_with_trait).name.should == "to_create"
+    FactoryGirl.create(:child_user_with_trait).name.should == "to_create"
+  end
+
+  it "gives base traits lower priority than overrides" do
+    FactoryGirl.create(:sub_user_with_trait_and_override).name.should == "sub with trait and override"
+    FactoryGirl.create(:child_user_with_trait_and_override).name.should == "sub with trait and override"
+  end
+
+  it "gives additional traits higher priority than base traits and factory definition" do
+    FactoryGirl.define do
+      trait :overridden do
+        to_create {|instance| instance.name = "completely overridden" }
+      end
+    end
+
+    FactoryGirl.create(:sub_user_with_trait_and_override, :overridden).name.should == "completely overridden"
+    FactoryGirl.create(:child_user_with_trait_and_override, :overridden).name.should == "completely overridden"
+  end
+end
+
+describe "traits with initialize_with" do
+  before do
+    define_class("User") do
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        trait :with_initialize_with do
+          initialize_with { new("initialize_with") }
+        end
+
+        factory :sub_user do
+          initialize_with { new("sub") }
+
+          factory :child_user
+        end
+
+        factory :sub_user_with_trait do
+          with_initialize_with
+
+          factory :child_user_with_trait
+        end
+
+        factory :sub_user_with_trait_and_override do
+          with_initialize_with
+          initialize_with { new("sub with trait and override") }
+
+          factory :child_user_with_trait_and_override
+        end
+      end
+    end
+  end
+
+  it "can apply initialize_with from traits" do
+    FactoryGirl.build(:user, :with_initialize_with).name.should == "initialize_with"
+  end
+
+  it "can apply initialize_with from the definition" do
+    FactoryGirl.build(:sub_user).name.should == "sub"
+    FactoryGirl.build(:child_user).name.should == "sub"
+  end
+
+  it "gives additional traits higher priority than initialize_with from the definition" do
+    FactoryGirl.build(:sub_user, :with_initialize_with).name.should == "initialize_with"
+    FactoryGirl.build(:child_user, :with_initialize_with).name.should == "initialize_with"
+  end
+
+  it "gives base traits normal priority" do
+    FactoryGirl.build(:sub_user_with_trait).name.should == "initialize_with"
+    FactoryGirl.build(:child_user_with_trait).name.should == "initialize_with"
+  end
+
+  it "gives base traits lower priority than overrides" do
+    FactoryGirl.build(:sub_user_with_trait_and_override).name.should == "sub with trait and override"
+    FactoryGirl.build(:child_user_with_trait_and_override).name.should == "sub with trait and override"
+  end
+
+  it "gives additional traits higher priority than base traits and factory definition" do
+    FactoryGirl.define do
+      trait :overridden do
+        initialize_with { new("completely overridden") }
+      end
+    end
+
+    FactoryGirl.build(:sub_user_with_trait_and_override, :overridden).name.should == "completely overridden"
+    FactoryGirl.build(:child_user_with_trait_and_override, :overridden).name.should == "completely overridden"
+  end
+end

data/spec/acceptance/transient_attributes_spec.rb

@@ -17,7 +17,7 @@ describe "transient attributes" do
         name  { "#{FactoryGirl.generate(:name)}#{" - Rockstar" if rockstar}" }
         email { "#{name.downcase}#{four}@example.com" }
 
-        after_create do |user, evaluator|
+        after(:create) do |user, evaluator|
           user.name.upcase! if evaluator.upcased
         end
       end

data/spec/factory_girl/attribute_list_spec.rb

@@ -73,6 +73,71 @@ describe FactoryGirl::AttributeList, "#associations" do
   end
 
   it "returns associations" do
-    subject.associations.should == [author_attribute, profile_attribute]
+    subject.associations.to_a.should == [author_attribute, profile_attribute]
+  end
+end
+
+describe FactoryGirl::AttributeList, "filter based on ignored attributes" do
+  def build_ignored_attribute(name)
+    FactoryGirl::Attribute::Static.new(name, "value", true)
+  end
+
+  def build_non_ignored_attribute(name)
+    FactoryGirl::Attribute::Static.new(name, "value", false)
+  end
+
+  before do
+    subject.define_attribute(build_ignored_attribute(:comments_count))
+    subject.define_attribute(build_ignored_attribute(:posts_count))
+    subject.define_attribute(build_non_ignored_attribute(:email))
+    subject.define_attribute(build_non_ignored_attribute(:first_name))
+    subject.define_attribute(build_non_ignored_attribute(:last_name))
+  end
+
+  it "filters #ignored attributes" do
+    subject.ignored.map(&:name).should == [:comments_count, :posts_count]
+  end
+
+  it "filters #non_ignored attributes" do
+    subject.non_ignored.map(&:name).should == [:email, :first_name, :last_name]
+  end
+end
+
+describe FactoryGirl::AttributeList, "generating names" do
+  def build_ignored_attribute(name)
+    FactoryGirl::Attribute::Static.new(name, "value", true)
+  end
+
+  def build_non_ignored_attribute(name)
+    FactoryGirl::Attribute::Static.new(name, "value", false)
+  end
+
+  def build_association(name)
+    FactoryGirl::Attribute::Association.new(name, :user, {})
+  end
+
+  before do
+    subject.define_attribute(build_ignored_attribute(:comments_count))
+    subject.define_attribute(build_ignored_attribute(:posts_count))
+    subject.define_attribute(build_non_ignored_attribute(:email))
+    subject.define_attribute(build_non_ignored_attribute(:first_name))
+    subject.define_attribute(build_non_ignored_attribute(:last_name))
+    subject.define_attribute(build_association(:avatar))
+  end
+
+  it "knows all its #names" do
+    subject.names.should == [:comments_count, :posts_count, :email, :first_name, :last_name, :avatar]
+  end
+
+  it "knows all its #names for #ignored attributes" do
+    subject.ignored.names.should == [:comments_count, :posts_count]
+  end
+
+  it "knows all its #names for #non_ignored attributes" do
+    subject.non_ignored.names.should == [:email, :first_name, :last_name, :avatar]
+  end
+
+  it "knows all its #names for #associations" do
+    subject.associations.names.should == [:avatar]
   end
 end

data/spec/factory_girl/attribute_spec.rb

@@ -8,7 +8,7 @@ describe FactoryGirl::Attribute do
   it { should_not be_association }
 
   it "raises an error when defining an attribute writer" do
-    error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
+    error_message = %{factory_girl uses 'test value' syntax rather than 'test = value'}
     expect {
       FactoryGirl::Attribute.new('test=', false)
     }.to raise_error(FactoryGirl::AttributeDefinitionError, error_message)

data/spec/factory_girl/definition_proxy_spec.rb

@@ -126,18 +126,18 @@ describe FactoryGirl::DefinitionProxy, "adding callbacks" do
   let(:proxy)    { FactoryGirl::DefinitionProxy.new(subject) }
   let(:callback) { -> { "my awesome callback!" } }
 
-  context "#after_build" do
-    before { proxy.after_build(&callback) }
+  context "#after(:build)" do
+    before { proxy.after(:build, &callback) }
     it     { should have_callback(:after_build).with_block(callback) }
   end
 
-  context "#after_create" do
-    before { proxy.after_create(&callback) }
+  context "#after(:create)" do
+    before { proxy.after(:create, &callback) }
     it     { should have_callback(:after_create).with_block(callback) }
   end
 
-  context "#after_stub" do
-    before { proxy.after_stub(&callback) }
+  context "#after(:stub)" do
+    before { proxy.after(:stub, &callback) }
     it     { should have_callback(:after_stub).with_block(callback) }
   end
 end

data/spec/factory_girl/definition_spec.rb

@@ -49,13 +49,7 @@ describe FactoryGirl::Definition, "adding callbacks" do
 end
 
 describe FactoryGirl::Definition, "#to_create" do
-  its(:to_create) { should be_a(Proc) }
-
-  it "calls save! on the object when run" do
-    instance = stub("model instance", :save! => true)
-    subject.to_create[instance]
-    instance.should have_received(:save!).once
-  end
+  its(:to_create) { should be_nil }
 
   it "returns the assigned value when given a block" do
     block = proc { nil }
@@ -64,9 +58,11 @@ describe FactoryGirl::Definition, "#to_create" do
   end
 end
 
-describe FactoryGirl::Definition, "#processing_order" do
+describe FactoryGirl::Definition, "#definition_list" do
   let(:female_trait) { FactoryGirl::Trait.new(:female) }
   let(:admin_trait)  { FactoryGirl::Trait.new(:admin) }
+  let(:female_definition) { female_trait.definition }
+  let(:admin_definition) { admin_trait.definition }
 
   before do
     subject.define_trait(female_trait)
@@ -75,17 +71,22 @@ describe FactoryGirl::Definition, "#processing_order" do
 
   context "without base traits" do
     it "returns the definition without any traits" do
-      subject.processing_order.should == [subject]
+      subject.definition_list.should == [subject]
+    end
+
+    it "finds the correct definitions after appending" do
+      subject.append_traits([:female])
+      subject.definition_list.should == [subject, female_definition]
     end
 
-    it "finds the correct traits after inheriting" do
+    it "finds the correct definitions after inheriting" do
       subject.inherit_traits([:female])
-      subject.processing_order.should == [subject, female_trait]
+      subject.definition_list.should == [female_definition, subject]
     end
 
     it "looks for the trait on FactoryGirl" do
-      subject.inherit_traits([:female, :admin])
-      subject.processing_order.should == [subject, female_trait, admin_trait]
+      subject.append_traits([:female, :admin])
+      subject.definition_list.should == [subject, female_definition, admin_definition]
     end
   end
 
@@ -93,12 +94,17 @@ describe FactoryGirl::Definition, "#processing_order" do
     subject { FactoryGirl::Definition.new("my definition", [:female]) }
 
     it "returns the base traits and definition" do
-      subject.processing_order.should == [female_trait, subject]
+      subject.definition_list.should == [female_definition, subject]
+    end
+
+    it "finds the correct definitions after appending" do
+      subject.append_traits([:admin])
+      subject.definition_list.should == [female_definition, subject, admin_definition]
     end
 
-    it "finds the correct traits after inheriting" do
+    it "finds the correct definitions after inheriting" do
       subject.inherit_traits([:admin])
-      subject.processing_order.should == [female_trait, subject, admin_trait]
+      subject.definition_list.should == [female_definition, admin_definition, subject]
     end
   end
 end

data/spec/factory_girl/factory_spec.rb

@@ -37,7 +37,7 @@ describe FactoryGirl::Factory do
     factory.associations.each do |association|
       association.should be_association
     end
-    factory.associations.size.should == 3
+    factory.associations.to_a.length.should == 3
   end
 
   it "includes associations from the parent factory" do
@@ -262,18 +262,20 @@ describe FactoryGirl::Factory, "#with_traits" do
   subject            { FactoryGirl::Factory.new(:user) }
   let(:admin_trait)  { FactoryGirl::Trait.new(:admin) }
   let(:female_trait) { FactoryGirl::Trait.new(:female) }
+  let(:admin_definition) { admin_trait.definition }
+  let(:female_definition) { female_trait.definition }
 
   before do
     FactoryGirl.register_trait(admin_trait)
     FactoryGirl.register_trait(female_trait)
   end
 
-  it "returns a factory with the correct traits" do
-    subject.with_traits([:admin, :female]).processing_order[1, 2].should == [admin_trait, female_trait]
+  it "returns a factory with the correct definitions" do
+    subject.with_traits([:admin, :female]).definition_list[1, 2].should == [admin_definition, female_definition]
   end
 
   it "doesn't modify the original factory's processing order" do
     subject.with_traits([:admin, :female])
-    subject.processing_order.should == [subject.definition]
+    subject.definition_list.should == [subject.definition]
   end
 end