factory_girl 2.3.2 → 2.4.0

data/lib/factory_girl/step_definitions.rb

@@ -114,13 +114,14 @@ FactoryGirl.factories.each do |factory|
 
     if factory.build_class.respond_to?(:columns)
       factory.build_class.columns.each do |column|
-        human_column_name = column.name.downcase.gsub('_', ' ')
+        name = column.respond_to?(:name) ? column.name : column.to_s
+        human_column_name = name.downcase.gsub('_', ' ')
         Given /^an? #{human_name} exists with an? #{human_column_name} of "([^"]*)"$/i do |value|
-          FactoryGirl.create(factory.name, column.name => value)
+          FactoryGirl.create(factory.name, name => value)
         end
 
         Given /^(\d+) #{human_name.pluralize} exist with an? #{human_column_name} of "([^"]*)"$/i do |count, value|
-          FactoryGirl.create_list(factory.name, count.to_i, column.name => value)
+          FactoryGirl.create_list(factory.name, count.to_i, name => value)
         end
       end
     end

data/lib/factory_girl/version.rb

@@ -1,4 +1,4 @@
 module FactoryGirl
-  VERSION = "2.3.2"
+  VERSION = "2.4.0"
 end
 

data/spec/acceptance/aliases_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "aliases and overrides" do
+  before do
+    Factory.alias /one/, "two"
+
+    define_model("User", :two => :string, :one => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        two "set value"
+      end
+    end
+  end
+
+  subject { FactoryGirl.create(:user, :one => "override") }
+  its(:one) { should == "override" }
+  its(:two) { should be_nil }
+end

data/spec/acceptance/attributes_for_spec.rb

@@ -40,7 +40,8 @@ describe "a generated attributes hash" do
   end
 
   it "doesn't assign associations" do
-    subject[:user_id].should be_nil
+    subject.should_not have_key(:user_id)
+    subject.should_not have_key(:user)
   end
 end
 
@@ -60,6 +61,14 @@ describe "calling `attributes_for` with a block" do
       attributes[:name].should eq('thoughtbot')
     end
   end
+
+  it "returns the hash of attributes" do
+    expected = nil
+    attributes_for(:company) do |attributes|
+      expected = attributes
+      "hello!"
+    end.should == expected
+  end
 end
 
 describe "`attributes_for` for a class whose constructor has required params" do

data/spec/acceptance/attributes_from_instance_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe "calling methods on the model instance" do
+  before do
+    define_model('User', :age => :integer, :age_copy => :integer) do
+      def age
+        read_attribute(:age) || 18
+      end
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        age_copy { age }
+      end
+    end
+  end
+
+  context "without the attribute being overridden" do
+    it "returns the correct value from the instance" do
+      FactoryGirl.build(:user).age_copy.should == 18
+    end
+
+    it "returns nil during attributes_for" do
+      FactoryGirl.attributes_for(:user)[:age_copy].should be_nil
+    end
+
+    it "doesn't instantiate a record with attributes_for" do
+      User.stubs(:new)
+      FactoryGirl.attributes_for(:user)
+      User.should have_received(:new).never
+    end
+  end
+
+  context "with the attribute being overridden" do
+    it "uses the overridden value" do
+      FactoryGirl.build(:user, :age_copy => nil).age_copy.should be_nil
+    end
+
+    it "uses the overridden value during attributes_for" do
+      FactoryGirl.attributes_for(:user, :age_copy => 25)[:age_copy].should == 25
+    end
+  end
+
+  context "with the referenced attribute being overridden" do
+    it "uses the overridden value" do
+      FactoryGirl.build(:user, :age => nil).age_copy.should be_nil
+    end
+
+    it "uses the overridden value during attributes_for" do
+      FactoryGirl.attributes_for(:user, :age => 25)[:age_copy].should == 25
+    end
+  end
+end

data/spec/acceptance/build_spec.rb

@@ -78,4 +78,12 @@ describe "calling `build` with a block" do
       company.name.should eq('thoughtbot')
     end
   end
+
+  it "returns the built instance" do
+    expected = nil
+    build(:company) do |company|
+      expected = company
+      "hello!"
+    end.should == expected
+  end
 end

data/spec/acceptance/build_stubbed_spec.rb

@@ -8,6 +8,7 @@ describe "a generated stub instance" do
 
     define_model('Post', :title   => :string,
                          :body    => :string,
+                         :age     => :integer,
                          :user_id => :integer) do
       belongs_to :user
     end
@@ -92,4 +93,12 @@ describe "calling `build_stubbed` with a block" do
       expect { company.save }.to raise_error(RuntimeError)
     end
   end
+
+  it "returns the stub instance" do
+    expected = nil
+    build_stubbed(:company) do |company|
+      expected = company
+      "hello!"
+    end.should == expected
+  end
 end

data/spec/acceptance/create_spec.rb

@@ -106,4 +106,12 @@ describe "calling `create` with a block" do
       company.name.should eq('thoughtbot')
     end
   end
+
+  it "returns the created instance" do
+    expected = nil
+    create(:company) do |company|
+      expected = company
+      "hello!"
+    end.should == expected
+  end
 end

data/spec/factory_girl/attribute/association_spec.rb

@@ -7,18 +7,19 @@ describe FactoryGirl::Attribute::Association do
   let(:association) { stub("association") }
   let(:proxy)       { stub("proxy", :association => association) }
 
-  subject    { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
+  subject { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
+  before  { subject.stubs(:association => association) }
 
   it         { should be_association }
   its(:name) { should == name }
 
   it "builds the association when calling the proc" do
-    subject.to_proc(proxy).call.should == association
+    subject.to_proc.call.should == association
   end
 
   it "builds the association when calling the proc" do
-    subject.to_proc(proxy).call
-    proxy.should have_received(:association).with(factory, overrides)
+    subject.to_proc.call
+    subject.should have_received(:association).with(factory, overrides)
   end
 end
 

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 describe FactoryGirl::Attribute::Dynamic do
   let(:name)  { :first_name }
-  let(:proxy) { stub("proxy", :set => nil) }
   let(:block) { lambda { } }
 
   subject { FactoryGirl::Attribute::Dynamic.new(name, false, block) }
@@ -13,28 +12,28 @@ describe FactoryGirl::Attribute::Dynamic do
     let(:block) { lambda { "value" } }
 
     it "returns the value when executing the proc" do
-      subject.to_proc(proxy).call.should == "value"
+      subject.to_proc.call.should == "value"
     end
   end
 
   context "with a block returning its block-level variable" do
     let(:block) { lambda {|thing| thing } }
 
-    it "returns the proxy when executing the proc" do
-      subject.to_proc(proxy).call.should == proxy
+    it "returns self when executing the proc" do
+      subject.to_proc.call.should == subject
     end
   end
 
-  context "with a block referencing an attribute on the proxy" do
-    let(:block)  { lambda { attribute_defined_on_proxy } }
+  context "with a block referencing an attribute on the attribute" do
+    let(:block)  { lambda { attribute_defined_on_attribute } }
     let(:result) { "other attribute value" }
 
     before do
-      proxy.stubs(:attribute_defined_on_proxy => result)
+      subject.stubs(:attribute_defined_on_attribute => result)
     end
 
-    it "evaluates the attribute from the proxy" do
-      subject.to_proc(proxy).call.should == result
+    it "evaluates the attribute from the attribute" do
+      subject.to_proc.call.should == result
     end
   end
 
@@ -42,7 +41,7 @@ describe FactoryGirl::Attribute::Dynamic do
     let(:block) { lambda { Factory.sequence(:email) } }
 
     it "raises a sequence abuse error" do
-      expect { subject.to_proc(proxy).call }.to raise_error(FactoryGirl::SequenceAbuseError)
+      expect { subject.to_proc.call }.to raise_error(FactoryGirl::SequenceAbuseError)
     end
   end
 end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -4,7 +4,6 @@ describe FactoryGirl::Attribute::Sequence do
   let(:sequence_name) { :name }
   let(:name)          { :first_name }
   let(:sequence)      { FactoryGirl::Sequence.new(sequence_name, 5) { |n| "Name #{n}" } }
-  let(:proxy)         { stub("proxy") }
 
   subject { FactoryGirl::Attribute::Sequence.new(name, sequence_name, false) }
   before  { FactoryGirl.register_sequence(sequence) }
@@ -12,6 +11,6 @@ describe FactoryGirl::Attribute::Sequence do
   its(:name) { should == name }
 
   it "assigns the next value in the sequence" do
-    subject.to_proc(proxy).call.should == "Name 5"
+    subject.to_proc.call.should == "Name 5"
   end
 end

data/spec/factory_girl/attribute/static_spec.rb

@@ -3,14 +3,13 @@ require 'spec_helper'
 describe FactoryGirl::Attribute::Static do
   let(:name)  { :first_name }
   let(:value) { "John" }
-  let(:proxy) { stub("proxy") }
 
   subject { FactoryGirl::Attribute::Static.new(name, value, false) }
 
   its(:name) { should == name }
 
   it "returns the value when executing the proc" do
-    subject.to_proc(proxy).call.should == value
+    subject.to_proc.call.should == value
   end
 end
 

data/spec/factory_girl/attribute_list_spec.rb

@@ -57,12 +57,22 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
     subject.apply_attributes(list(city_attribute, email_attribute))
     subject.to_a.should == [full_name_attribute, login_attribute, city_attribute, email_attribute]
   end
+end
+
+describe FactoryGirl::AttributeList, "#associations" do
+  let(:full_name_attribute) { FactoryGirl::Attribute::Static.new(:full_name, "value", false) }
+  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, false, lambda {|u| "#{u.full_name}@example.com" }) }
+  let(:author_attribute)    { FactoryGirl::Attribute::Association.new(:author, :user, {}) }
+  let(:profile_attribute)   { FactoryGirl::Attribute::Association.new(:profile, :profile, {}) }
 
-  it "doesn't overwrite attributes that are already defined" do
+  before do
     subject.define_attribute(full_name_attribute)
-    attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin", false)
+    subject.define_attribute(email_attribute)
+    subject.define_attribute(author_attribute)
+    subject.define_attribute(profile_attribute)
+  end
 
-    subject.apply_attributes(list(attribute_with_same_name))
-    subject.to_a.should == [full_name_attribute]
+  it "returns associations" do
+    subject.associations.should == [author_attribute, profile_attribute]
   end
 end

data/spec/factory_girl/evaluator_class_definer_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe FactoryGirl::EvaluatorClassDefiner do
+  let(:simple_attribute)                    { stub("simple attribute",   :name => :simple, :to_proc => lambda { 1 }) }
+  let(:relative_attribute)                  { stub("relative attribute", :name => :relative, :to_proc => lambda { simple + 1 }) }
+  let(:attribute_that_raises_a_second_time) { stub("attribute that would raise without a cache", :name => :raises_without_proper_cache, :to_proc => lambda { raise "failed" if @run; @run = true; nil }) }
+  let(:callbacks) { [stub("callback 1"), stub("callback 2")] }
+
+  let(:attributes)    { [simple_attribute, relative_attribute, attribute_that_raises_a_second_time] }
+  let(:class_definer) { FactoryGirl::EvaluatorClassDefiner.new(attributes, callbacks, FactoryGirl::Evaluator) }
+  let(:evaluator)     { class_definer.evaluator_class.new(stub("build strategy", :add_observer => true)) }
+
+  it "returns an evaluator when accessing the evaluator class" do
+    evaluator.should be_a(FactoryGirl::Evaluator)
+  end
+
+  it "adds each attribute to the evaluator" do
+    evaluator.simple.should == 1
+  end
+
+  it "evaluates the block in the context of the evaluator" do
+    evaluator.relative.should == 2
+  end
+
+  it "only instance_execs the block once even when returning nil" do
+    expect {
+      2.times { evaluator.raises_without_proper_cache }
+    }.to_not raise_error
+  end
+
+  it "sets attributes on the evaluator class" do
+    class_definer.evaluator_class.attribute_lists.should == [attributes]
+  end
+
+  it "sets callbacks on the evaluator class" do
+    class_definer.evaluator_class.callbacks.should == callbacks
+  end
+
+  context "with a custom evaluator as a parent class" do
+    let(:child_callbacks)  { [stub("child callback 1"), stub("child callback 2")] }
+    let(:child_attributes) { [stub("child attribute", :name => :simple, :to_proc => lambda { 1 })] }
+    let(:child_definer)    { FactoryGirl::EvaluatorClassDefiner.new(child_attributes, child_callbacks, class_definer.evaluator_class) }
+
+    subject { child_definer.evaluator_class }
+
+    it "bases its attribute lists on itself and its parent evaluator" do
+      subject.attribute_lists.should == [attributes, child_attributes]
+    end
+
+    it "bases its callbacks on itself and its parent evaluator" do
+      subject.callbacks.should == callbacks + child_callbacks
+    end
+  end
+end

data/spec/factory_girl/factory_spec.rb

@@ -25,7 +25,7 @@ describe FactoryGirl::Factory do
   end
 
   it "passes a custom creation block" do
-    proxy = stub("proxy", :result => nil)
+    proxy = stub("proxy", :result => nil, :add_observer => true)
     FactoryGirl::Proxy::Build.stubs(:new => proxy)
     block = lambda {}
     factory = FactoryGirl::Factory.new(:object)
@@ -33,7 +33,7 @@ describe FactoryGirl::Factory do
 
     factory.run(FactoryGirl::Proxy::Build, {})
 
-    proxy.should have_received(:result).with(block)
+    proxy.should have_received(:result).with(instance_of(FactoryGirl::AttributeAssigner), block)
   end
 
   it "returns associations" do
@@ -116,6 +116,25 @@ describe FactoryGirl::Factory, "when defined with a custom class" do
   its(:build_class) { should == Float }
 end
 
+describe FactoryGirl::Factory, "when given a class that overrides #to_s" do
+  let(:overriding_class) { Overriding::Class }
+
+  before do
+    define_class("Overriding")
+    define_class("Overriding::Class") do
+      def self.to_s
+        "Overriding"
+      end
+    end
+  end
+
+  subject { FactoryGirl::Factory.new(:overriding_class, :class => Overriding::Class) }
+
+  it "sets build_class correctly" do
+    subject.build_class.should == overriding_class
+  end
+end
+
 describe FactoryGirl::Factory, "when defined with a class instead of a name" do
   let(:factory_class) { ArgumentError }
   let(:name)          { :argument_error }
@@ -246,7 +265,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", :set => nil) }
+  let(:proxy)          { stub("proxy", :result => "result", :add_observer => true) }
   let(:attributes)     { [attribute] }
   let(:attribute_list) { stub('attribute-list', :declarations => [declaration], :to_a => attributes) }
 
@@ -254,29 +273,17 @@ describe FactoryGirl::Factory, "running a factory" do
     define_model("User", :name => :string)
     FactoryGirl::Declaration::Static.stubs(:new => declaration)
     declaration.stubs(:to_attributes => attributes)
-    attribute.stubs(:add_to => nil)
     FactoryGirl::Proxy::Build.stubs(:new => proxy)
     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).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)
+    FactoryGirl::Proxy::Build.should have_received(:new).once
   end
 
   it "returns the result from the proxy when running" do
     subject.run(FactoryGirl::Proxy::Build, {}).should == "result"
-    proxy.should have_received(:result).with(subject.definition.to_create)
-  end
-
-  it "sets overrides once on the factory" do
-    subject.run(FactoryGirl::Proxy::Build, { :name => "John Doe" })
-    proxy.should have_received(:set).once
   end
 
   it "calls the block and returns the result" do