factory_girl 2.5.2 → 2.6.0

data/lib/factory_girl/version.rb

@@ -1,4 +1,4 @@
 module FactoryGirl
-  VERSION = "2.5.2"
+  VERSION = "2.6.0"
 end
 

data/spec/acceptance/build_spec.rb

@@ -31,7 +31,7 @@ describe "a built instance" do
   end
 end
 
-describe "a built instance with :method => :build" do
+describe "a built instance with :strategy => :build" do
   include FactoryGirl::Syntax::Methods
 
   before do
@@ -45,7 +45,7 @@ describe "a built instance with :method => :build" do
       factory :user
 
       factory :post do
-        association(:user, :method => :build)
+        association(:user, :strategy => :build)
       end
     end
   end

data/spec/acceptance/create_list_spec.rb

@@ -39,3 +39,44 @@ describe "create multiple instances" do
     end
   end
 end
+
+describe "multiple creates and ignored attributes to dynamically build attribute lists" do
+  before do
+    define_model('User', :name => :string) do
+      has_many :posts
+    end
+
+    define_model('Post', :title => :string, :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :post do
+        title "Through the Looking Glass"
+        user
+      end
+
+      factory :user do
+        name "John Doe"
+
+        factory :user_with_posts do
+          ignore do
+            posts_count 5
+          end
+
+          after_create do |user, evaluator|
+            FactoryGirl.create_list(:post, evaluator.posts_count, :user => user)
+          end
+        end
+      end
+    end
+  end
+
+  it "generates the correct number of posts" do
+    FactoryGirl.create(:user_with_posts).posts.length.should == 5
+  end
+
+  it "allows the number of posts to be modified" do
+    FactoryGirl.create(:user_with_posts, :posts_count => 2).posts.length.should == 2
+  end
+end

data/spec/acceptance/create_spec.rb

@@ -31,30 +31,59 @@ describe "a created instance" do
   end
 end
 
-describe "a created instance, specifying :method => build" do
+describe "a created instance, specifying :strategy => build" do
   include FactoryGirl::Syntax::Methods
 
-  before do
-    define_model('User')
+  def define_factories_with_method
+    FactoryGirl.define do
+      factory :user
 
-    define_model('Post', :user_id => :integer) do
-      belongs_to :user
+      factory :post do
+        association(:user, :method => :build)
+      end
     end
+  end
 
+  def define_factories_with_strategy
     FactoryGirl.define do
       factory :user
 
       factory :post do
-        association(:user, :method => :build)
+        association(:user, :strategy => :build)
       end
     end
   end
 
-  subject { create('post') }
+  before do
+    define_model('User')
 
-  it "still saves associations (:method => :build only affects build, not create)" do
-    subject.user.should be_kind_of(User)
-    subject.user.should_not be_new_record
+    define_model('Post', :user_id => :integer) do
+      belongs_to :user
+    end
+  end
+
+  context "associations declared with :strategy" do
+    before  { define_factories_with_strategy }
+    subject { build_stubbed(:post) }
+
+    subject { create('post') }
+
+    it "still saves associations (:strategy => :build only affects build, not create)" do
+      subject.user.should be_kind_of(User)
+      subject.user.should_not be_new_record
+    end
+  end
+
+  context "associations declared with :method" do
+    before  { define_factories_with_method }
+    subject { build_stubbed(:post) }
+
+    subject { create('post') }
+
+    it "still saves associations (:method => :build only affects build, not create)" do
+      subject.user.should be_kind_of(User)
+      subject.user.should_not be_new_record
+    end
   end
 end
 

data/spec/acceptance/stub_spec.rb

@@ -31,34 +31,61 @@ describe "a stubbed instance" do
   end
 end
 
-describe "a stubbed instance with :method => :build" do
+describe "a stubbed instance overriding strategy" do
   include FactoryGirl::Syntax::Methods
 
-  before do
-    define_model('User')
+  def define_factories_with_method
+    FactoryGirl.define do
+      factory :user
 
-    define_model('Post', :user_id => :integer) do
-      belongs_to :user
+      factory :post do
+        association(:user, :method => :build)
+      end
     end
+  end
 
+  def define_factories_with_strategy
     FactoryGirl.define do
       factory :user
 
       factory :post do
-        association(:user, :method => :build)
+        association(:user, :strategy => :build)
       end
     end
   end
 
-  subject { build_stubbed(:post) }
-
-  it "acts as if it is saved in the database" do
-    should_not be_new_record
+  before do
+    define_model('User')
+    define_model('Post', :user_id => :integer) do
+      belongs_to :user
+    end
   end
 
-  it "assigns associations and acts as if it is saved" do
-    subject.user.should be_kind_of(User)
-    subject.user.should_not be_new_record
+  context "associations declared with :strategy" do
+    before  { define_factories_with_strategy }
+    subject { build_stubbed(:post) }
+
+    it "acts as if it is saved in the database" do
+      should_not be_new_record
+    end
+
+    it "assigns associations and acts as if it is saved" do
+      subject.user.should be_kind_of(User)
+      subject.user.should_not be_new_record
+    end
   end
 
+  context "associations declared with :method" do
+    before  { define_factories_with_method }
+    subject { build_stubbed(:post) }
+
+    it "acts as if it is saved in the database" do
+      should_not be_new_record
+    end
+
+    it "assigns associations and acts as if it is saved" do
+      subject.user.should be_kind_of(User)
+      subject.user.should_not be_new_record
+    end
+  end
 end

data/spec/acceptance/syntax/vintage_spec.rb

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

data/spec/acceptance/traits_spec.rb

@@ -210,7 +210,7 @@ describe "traits with callbacks" do
   end
 end
 
-describe "traits added via proxy" do
+describe "traits added via strategy" do
   before do
     define_model("User", :name => :string, :admin => :boolean)
 

data/spec/acceptance/transient_attributes_spec.rb

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

data/spec/factory_girl/association_runner_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe FactoryGirl::AssociationRunner do
+  let(:factory)  { stub("factory", :run => instance) }
+  let(:instance) { stub("instance") }
+
+  before do
+    FactoryGirl.stubs(:factory_by_name => factory)
+  end
+
+  it "passes all overrides to the factory" do
+    FactoryGirl::AssociationRunner.new(:user, FactoryGirl::Strategy::Build, :strategy => :build, :name => "John").run
+    factory.should have_received(:run).with(FactoryGirl::Strategy::Build, :strategy => :build, :name => "John")
+  end
+
+  it "runs a strategy inferred by name based on a factory name" do
+    FactoryGirl::AssociationRunner.new(:user, :build, :strategy => :build, :name => "John").run
+    factory.should have_received(:run).with(FactoryGirl::Strategy::Build, :strategy => :build, :name => "John")
+  end
+
+  it "allows overriding strategy" do
+    FactoryGirl::AssociationRunner.new(:user, :build, :strategy => :build, :name => "John").run(FactoryGirl::Strategy::Create)
+    factory.should have_received(:run).with(FactoryGirl::Strategy::Create, :strategy => :build, :name => "John")
+  end
+
+  it "raises if the strategy cannot be inferred" do
+    expect do
+      FactoryGirl::AssociationRunner.new(:user, :bogus_strategy, :strategy => :build, :name => "John").run
+    end.to raise_error("unrecognized method bogus_strategy")
+  end
+end

data/spec/factory_girl/attribute/association_spec.rb

@@ -5,7 +5,6 @@ describe FactoryGirl::Attribute::Association do
   let(:factory)     { :user }
   let(:overrides)   { { :first_name => "John" } }
   let(:association) { stub("association") }
-  let(:proxy)       { stub("proxy", :association => association) }
 
   subject { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
   before  { subject.stubs(:association => association) }

data/spec/factory_girl/attribute_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe FactoryGirl::Attribute do
   let(:name)  { "user" }
-  let(:proxy) { stub("proxy") }
   subject     { FactoryGirl::Attribute.new(name, false) }
 
   its(:name) { should == name.to_sym }

data/spec/factory_girl/declaration/implicit_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe FactoryGirl::Declaration::Implicit do
   let(:name)        { :author }
-  let(:proxy)       { stub("proxy") }
   let(:declaration) { FactoryGirl::Declaration::Implicit.new(name) }
   subject           { declaration.to_attributes.first }
 

data/spec/factory_girl/factory_spec.rb

@@ -25,15 +25,15 @@ describe FactoryGirl::Factory do
   end
 
   it "passes a custom creation block" do
-    proxy = stub("proxy", :result => nil, :add_observer => true)
-    FactoryGirl::Proxy::Build.stubs(:new => proxy)
+    strategy = stub("strategy", :result => nil, :add_observer => true)
+    FactoryGirl::Strategy::Build.stubs(:new => strategy)
     block = lambda {}
     factory = FactoryGirl::Factory.new(:object)
     factory.to_create(&block)
 
-    factory.run(FactoryGirl::Proxy::Build, {})
+    factory.run(FactoryGirl::Strategy::Build, {})
 
-    proxy.should have_received(:result).with(instance_of(FactoryGirl::AttributeAssigner), block)
+    strategy.should have_received(:result).with(instance_of(FactoryGirl::AttributeAssigner), block)
   end
 
   it "returns associations" do
@@ -72,21 +72,21 @@ describe FactoryGirl::Factory do
     it "returns the overridden value in the generated attributes" do
       declaration = FactoryGirl::Declaration::Static.new(@name, 'The price is wrong, Bob!')
       @factory.declare_attribute(declaration)
-      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      result = @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
       result[@name].should == @value
     end
 
     it "does not call a lazy attribute block for an overridden attribute" do
       declaration = FactoryGirl::Declaration::Dynamic.new(@name, false, lambda { flunk })
       @factory.declare_attribute(declaration)
-      @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
     end
 
     it "overrides a symbol parameter with a string parameter" do
       declaration = FactoryGirl::Declaration::Static.new(@name, 'The price is wrong, Bob!')
       @factory.declare_attribute(declaration)
       @hash = { @name.to_s => @value }
-      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      result = @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
       result[@name].should == @value
     end
   end
@@ -95,7 +95,7 @@ describe FactoryGirl::Factory do
     before do
       @factory.declare_attribute(FactoryGirl::Declaration::Static.new(:test, 'original'))
       Factory.alias(/(.*)_alias/, '\1')
-      @result = @factory.run(FactoryGirl::Proxy::AttributesFor,
+      @result = @factory.run(FactoryGirl::Strategy::AttributesFor,
                              :test_alias => 'new')
     end
 
@@ -279,7 +279,7 @@ describe FactoryGirl::Factory, "running a factory" do
   subject              { FactoryGirl::Factory.new(:user) }
   let(:attribute)      { FactoryGirl::Attribute::Static.new(:name, "value", false) }
   let(:declaration)    { FactoryGirl::Declaration::Static.new(:name, "value", false) }
-  let(:proxy)          { stub("proxy", :result => "result", :add_observer => true) }
+  let(:strategy)       { stub("strategy", :result => "result", :add_observer => true) }
   let(:attributes)     { [attribute] }
   let(:attribute_list) { stub('attribute-list', :declarations => [declaration], :to_a => attributes) }
 
@@ -287,23 +287,23 @@ describe FactoryGirl::Factory, "running a factory" do
     define_model("User", :name => :string)
     FactoryGirl::Declaration::Static.stubs(:new => declaration)
     declaration.stubs(:to_attributes => attributes)
-    FactoryGirl::Proxy::Build.stubs(:new => proxy)
+    FactoryGirl::Strategy::Build.stubs(:new => strategy)
     subject.declare_attribute(declaration)
   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).once
+  it "creates the right strategy using the build class when running" do
+    subject.run(FactoryGirl::Strategy::Build, {})
+    FactoryGirl::Strategy::Build.should have_received(:new).once
   end
 
-  it "returns the result from the proxy when running" do
-    subject.run(FactoryGirl::Proxy::Build, {}).should == "result"
+  it "returns the result from the strategy when running" do
+    subject.run(FactoryGirl::Strategy::Build, {}).should == "result"
   end
 
   it "calls the block and returns the result" do
     block_run = nil
     block = lambda {|result| block_run = "changed" }
-    subject.run(FactoryGirl::Proxy::Build, { }, &block)
+    subject.run(FactoryGirl::Strategy::Build, { }, &block)
     block_run.should == "changed"
   end
 end

data/spec/factory_girl/{proxy → strategy}/attributes_for_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe FactoryGirl::Proxy::AttributesFor do
+describe FactoryGirl::Strategy::AttributesFor do
   let(:result)             { { :name => "John Doe", :gender => "Male", :admin => false } }
   let(:attribute_assigner) { stub("attribute assigner", :hash => result) }
 
-  it_should_behave_like "proxy without association support"
+  it_should_behave_like "strategy without association support"
 
   it "returns the hash from the attribute assigner" do
     subject.result(attribute_assigner, lambda {|item| item }).should == result