factory_girl 2.3.1 → 2.3.2

data/lib/factory_girl/proxy/create.rb

@@ -4,11 +4,10 @@ module FactoryGirl
       def result(to_create)
         super
 
-        to_create ||= lambda {|instance| instance.save! }
-        to_create[@instance]
+        to_create[result_instance]
 
         run_callbacks(:after_create)
-        @instance
+        result_instance
       end
     end
   end

data/lib/factory_girl/proxy/stub.rb

@@ -5,9 +5,8 @@ module FactoryGirl
 
       def initialize(klass, callbacks = [])
         super
-        @instance = klass.new
-        @instance.id = next_id
-        @instance.instance_eval do
+        result_instance.id = next_id
+        result_instance.instance_eval do
           def persisted?
             !new_record?
           end
@@ -42,18 +41,6 @@ module FactoryGirl
         end
       end
 
-      def get(attribute)
-        if @ignored_attributes.has_key?(attribute)
-          @ignored_attributes[attribute]
-        else
-          @instance.send(attribute)
-        end
-      end
-
-      def set(attribute, value)
-        @instance.send(:"#{attribute.name}=", value)
-      end
-
       def association(factory_name, overrides = {})
         factory = FactoryGirl.factory_by_name(factory_name)
         factory.run(Proxy::Stub, overrides.except(:method))
@@ -61,7 +48,7 @@ module FactoryGirl
 
       def result(to_create)
         run_callbacks(:after_stub)
-        @instance
+        result_instance
       end
 
       private

data/lib/factory_girl/version.rb

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

data/spec/acceptance/attributes_for_spec.rb

@@ -61,3 +61,20 @@ describe "calling `attributes_for` with a block" do
     end
   end
 end
+
+describe "`attributes_for` for a class whose constructor has required params" do
+  before do
+    define_model("User", :name => :string) do
+      def initialize(arg1, arg2); end
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        name "John Doe"
+      end
+    end
+  end
+
+  subject      { FactoryGirl.attributes_for(:user) }
+  its([:name]) { should == "John Doe" }
+end

data/spec/acceptance/traits_spec.rb

@@ -263,3 +263,26 @@ describe "traits added via proxy" do
     its(:name)  { should == "Jack" }
   end
 end
+
+describe "traits and dynamic attributes that are applied simultaneously" do
+  before do
+    define_model("User", :name => :string, :email => :string, :combined => :string)
+
+    FactoryGirl.define do
+      trait :email do
+        email { "#{name}@example.com" }
+      end
+
+      factory :user do
+        name "John"
+        email
+        combined { "#{name} <#{email}>" }
+      end
+    end
+  end
+
+  subject        { FactoryGirl.build(:user) }
+  its(:name)     { should == "John" }
+  its(:email)    { should == "John@example.com" }
+  its(:combined) { should == "John <John@example.com>" }
+end

data/spec/factory_girl/attribute/association_spec.rb

@@ -1,22 +1,23 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Association do
-  let(:name)      { :author }
-  let(:factory)   { :user }
-  let(:overrides) { { :first_name => "John" } }
-  let(:proxy)     { stub("proxy") }
+  let(:name)        { :author }
+  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) }
+  subject    { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
 
-  it            { should be_association }
-  its(:name)    { should == name }
-  its(:factory) { should == factory }
+  it         { should be_association }
+  its(:name) { should == name }
 
-  it "tells the proxy to set the association when being added" do
-    association = stub("association")
-    proxy.stubs(:set => nil, :association => association)
-    subject.add_to(proxy)
-    proxy.should have_received(:set).with(subject, association)
+  it "builds the association when calling the proc" do
+    subject.to_proc(proxy).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)
   end
 end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -12,18 +12,16 @@ describe FactoryGirl::Attribute::Dynamic do
   context "with a block returning a static value" do
     let(:block) { lambda { "value" } }
 
-    it "calls the block to set a value" do
-      subject.add_to(proxy)
-      proxy.should have_received(:set).with(subject, "value")
+    it "returns the value when executing the proc" do
+      subject.to_proc(proxy).call.should == "value"
     end
   end
 
   context "with a block returning its block-level variable" do
     let(:block) { lambda {|thing| thing } }
 
-    it "yields the proxy to the block" do
-      subject.add_to(proxy)
-      proxy.should have_received(:set).with(subject, proxy)
+    it "returns the proxy when executing the proc" do
+      subject.to_proc(proxy).call.should == proxy
     end
   end
 
@@ -36,8 +34,7 @@ describe FactoryGirl::Attribute::Dynamic do
     end
 
     it "evaluates the attribute from the proxy" do
-      subject.add_to(proxy)
-      proxy.should have_received(:set).with(subject, result)
+      subject.to_proc(proxy).call.should == result
     end
   end
 
@@ -45,7 +42,7 @@ describe FactoryGirl::Attribute::Dynamic do
     let(:block) { lambda { Factory.sequence(:email) } }
 
     it "raises a sequence abuse error" do
-      expect { subject.add_to(proxy) }.to raise_error(FactoryGirl::SequenceAbuseError)
+      expect { subject.to_proc(proxy).call }.to raise_error(FactoryGirl::SequenceAbuseError)
     end
   end
 end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -12,8 +12,6 @@ describe FactoryGirl::Attribute::Sequence do
   its(:name) { should == name }
 
   it "assigns the next value in the sequence" do
-    proxy.stubs(:set)
-    subject.add_to(proxy)
-    proxy.should have_received(:set).with(subject, "Name 5")
+    subject.to_proc(proxy).call.should == "Name 5"
   end
 end

data/spec/factory_girl/attribute/static_spec.rb

@@ -9,10 +9,8 @@ describe FactoryGirl::Attribute::Static do
 
   its(:name) { should == name }
 
-  it "sets its static value on a proxy" do
-    proxy.stubs(:set)
-    subject.add_to(proxy)
-    proxy.should have_received(:set).with(subject, value)
+  it "returns the value when executing the proc" do
+    subject.to_proc(proxy).call.should == value
   end
 end
 

data/spec/factory_girl/attribute_list_spec.rb

@@ -51,23 +51,11 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
     end
   end
 
-  it "prepends applied attributes" do
-    subject.define_attribute(full_name_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(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
+  it "adds attributes in the order defined regardless of attribute type" do
     subject.define_attribute(full_name_attribute)
     subject.define_attribute(login_attribute)
     subject.apply_attributes(list(city_attribute, email_attribute))
-    subject.to_a.should == [city_attribute, full_name_attribute, email_attribute, login_attribute]
+    subject.to_a.should == [full_name_attribute, login_attribute, city_attribute, email_attribute]
   end
 
   it "doesn't overwrite attributes that are already defined" do

data/spec/factory_girl/attribute_spec.rb

@@ -8,25 +8,10 @@ describe FactoryGirl::Attribute do
   its(:name) { should == name.to_sym }
   it { should_not be_association }
 
-  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 "raises an error when defining an attribute writer" do
     error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
     expect {
       FactoryGirl::Attribute.new('test=', false)
     }.to raise_error(FactoryGirl::AttributeDefinitionError, error_message)
   end
-
-  it "returns nil when compared to a non-attribute" do
-    (subject <=> "foo").should be_nil
-  end
-
-  it "uses priority to perform comparisons" do
-    second_attribute = FactoryGirl::Attribute.new('name', false)
-    (subject <=> second_attribute).should be_zero
-  end
 end

data/spec/factory_girl/declaration/implicit_spec.rb

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

data/spec/factory_girl/definition_spec.rb

@@ -49,7 +49,13 @@ describe FactoryGirl::Definition, "adding callbacks" do
 end
 
 describe FactoryGirl::Definition, "#to_create" do
-  its(:to_create) { should be_nil }
+  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
 
   it "returns the assigned value when given a block" do
     block = proc { nil }

data/spec/factory_girl/factory_spec.rb

@@ -271,7 +271,7 @@ describe FactoryGirl::Factory, "running a factory" do
 
   it "returns the result from the proxy when running" do
     subject.run(FactoryGirl::Proxy::Build, {}).should == "result"
-    proxy.should have_received(:result).with(nil)
+    proxy.should have_received(:result).with(subject.definition.to_create)
   end
 
   it "sets overrides once on the factory" do

data/spec/factory_girl/proxy/attributes_for_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::AttributesFor do
-  let(:proxy_class) { stub("class") }
+  let(:proxy_class) { stub("proxy_class") }
 
   subject { FactoryGirl::Proxy::AttributesFor.new(proxy_class) }
 
@@ -11,18 +11,23 @@ describe FactoryGirl::Proxy::AttributesFor do
     subject.result(nil).should be_kind_of(Hash)
   end
 
+  it "does not instantiate the proxy class" do
+    proxy_class.stubs(:new)
+    subject.result(nil)
+    proxy_class.should have_received(:new).never
+  end
+
   describe "after setting an attribute" do
     let(:attribute) { stub("attribute", :name => :attribute) }
-    let(:value)     { "value" }
 
-    before { subject.set(attribute, value) }
+    before { subject.set(attribute, lambda { "value" }) }
 
     it "sets that value in the resulting hash" do
-      subject.result(nil)[:attribute].should == value
+      subject.result(nil)[:attribute].should == "value"
     end
 
     it "returns that value when asked for that attribute" do
-      subject.get(:attribute).should == value
+      subject.get(:attribute).should == "value"
     end
   end
 end

data/spec/factory_girl/proxy/create_spec.rb

@@ -11,11 +11,6 @@ describe FactoryGirl::Proxy::Create do
   it_should_behave_like "proxy with callbacks", :after_build
   it_should_behave_like "proxy with callbacks", :after_create
 
-  it "saves the instance before returning the result" do
-    subject.result(nil)
-    instance.should have_received(:save!)
-  end
-
   it "runs a custom create block" do
     block_run = false
     block = lambda {|instance| block_run = true }
@@ -23,7 +18,6 @@ describe FactoryGirl::Proxy::Create do
     instance.should have_received(:save!).never
     block_run.should be_true
   end
-
 end
 
 describe FactoryGirl::Proxy::Create, "when running callbacks" do
@@ -38,7 +32,7 @@ describe FactoryGirl::Proxy::Create, "when running callbacks" do
   subject { FactoryGirl::Proxy::Create.new(proxy_class, [after_create_one, after_create_two, after_build_one]) }
 
   it "runs callbacks in the correct order" do
-    subject.result(nil)
+    subject.result(lambda {|instance| instance })
     callback_result.should == [:after_build_one, :after_create_one, :after_create_two]
   end
 end

data/spec/factory_girl/proxy_spec.rb

@@ -6,11 +6,8 @@ describe FactoryGirl::Proxy do
   it_should_behave_like "proxy without association support"
 
   it "doesn't raise when assigning a value to an attribute" do
-    expect { subject.set(:name, "a name") }.to_not raise_error
-  end
-
-  it "returns nil for an attribute without a value" do
-    subject.get(:name).should be_nil
+    name_attribute = FactoryGirl::Attribute::Static.new(:name, "great", false)
+    expect { subject.set(name_attribute, lambda { "a name" }) }.to_not raise_error
   end
 
   it "calls get for a missing method" do

data/spec/support/shared_examples/proxy.rb

@@ -3,13 +3,12 @@ shared_examples_for "proxy without association support" do
 
   it "does not call FactoryGirl.create when building an association" do
     FactoryGirl.stubs(:create)
-    subject.set(attribute, "awesome")
+    subject.set(attribute, lambda { "awesome" })
     FactoryGirl.should have_received(:create).never
   end
 
   it "returns nil when accessing an association" do
-    subject.set(attribute, "awesome")
-    subject.get(:user).should be_nil
+    subject.association(:user, {}).should be_nil
   end
 
   it "does not attempt to look up the factory when accessing the association" do
@@ -70,7 +69,8 @@ shared_examples_for "proxy with standard getters and setters" do |attribute, val
 
   describe "when setting an attribute" do
     before do
-      subject.set(attribute_instance, value)
+      subject.set(attribute_instance, lambda { value })
+      subject.result(lambda {|instance| instance })
     end
 
     its(attribute) { should == value }
@@ -79,19 +79,20 @@ shared_examples_for "proxy with standard getters and setters" do |attribute, val
 
   describe "when setting an ignored attribute" do
     before do
-      subject.set_ignored(attribute_instance, value)
+      subject.set_ignored(attribute_instance, lambda { value })
+      subject.result(lambda {|instance| instance })
     end
 
     it { instance.should have_received(:"#{attribute}=").with(value).never }
   end
 
   describe "when getting an attribute" do
-    it { subject.get(attribute).should == value }
-
-    it "retrieves the value from the instance" do
-      subject.get(attribute)
-      instance.should have_received(:"#{attribute}")
+    before do
+      subject.set(attribute_instance, lambda { value })
+      subject.result(lambda {|instance| instance })
     end
+
+    it { subject.get(attribute).should == value }
   end
 end
 
@@ -102,11 +103,11 @@ shared_examples_for "proxy with callbacks" do |callback_name|
   subject        { described_class.new(proxy_class, [callback]) }
 
   it "runs the #{callback_name} callback" do
-    subject.result(nil)
+    subject.result(lambda {|instance| instance })
     callback_instance.should have_received(:foo).once
   end
 
   it "returns the proxy instance" do
-    subject.result(nil).should == instance
+    subject.result(lambda {|instance| instance }).should == instance
   end
 end