factory_girl 2.0.4 → 2.0.5

data/spec/factory_girl/find_definitions_spec.rb

@@ -2,15 +2,16 @@ require 'spec_helper'
 
 share_examples_for "finds definitions" do
   before do
-    stub(FactoryGirl).load
+    FactoryGirl.stubs(:load)
     FactoryGirl.find_definitions
   end
+
   subject { FactoryGirl }
 end
 
 RSpec::Matchers.define :load_definitions_from do |file|
   match do |given|
-    @has_received = have_received.method_missing(:load, File.expand_path(file))
+    @has_received = have_received(:load).with(File.expand_path(file))
     @has_received.matches?(given)
   end
 
@@ -23,7 +24,6 @@ RSpec::Matchers.define :load_definitions_from do |file|
   end
 end
 
-
 describe "definition loading" do
   def self.in_directory_with_files(*files)
     before do
@@ -79,10 +79,11 @@ describe "definition loading" do
       in_directory_with_files File.join(dir, 'factories', 'b.rb'),
                               File.join(dir, 'factories', 'a.rb')
       it "should load the files in the right order" do
-        @loaded = []
-        stub(FactoryGirl).load { |a| @loaded << File.split(a)[-1] }
+        FactoryGirl.stubs(:load)
+        sorted_load_order = sequence("load order")
+        FactoryGirl.expects(:load).with(includes("a.rb")).in_sequence(sorted_load_order)
+        FactoryGirl.expects(:load).with(includes("b.rb")).in_sequence(sorted_load_order)
         FactoryGirl.find_definitions
-        @loaded.should == ["a.rb", "b.rb"]
       end
     end
 

data/spec/factory_girl/proxy/attributes_for_spec.rb

@@ -1,51 +1,42 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::AttributesFor do
-  before do
-    @proxy = FactoryGirl::Proxy::AttributesFor.new(@class)
-  end
+  let(:proxy_class) { stub("class") }
 
-  describe "when asked to associate with another factory" do
-    before do
-      stub(FactoryGirl).create
-      @proxy.associate(:owner, :user, {})
-    end
+  subject { FactoryGirl::Proxy::AttributesFor.new(proxy_class) }
 
-    it "should not set a value for the association" do
-      (@proxy.result(nil).key?(:owner)).should_not be
-    end
-  end
+  it_should_behave_like "proxy without association support"
 
-  it "should return nil when building an association" do
-    @proxy.association(:user).should be_nil
+  it "returns a hash when asked for the result" do
+    subject.result(nil).should be_kind_of(Hash)
   end
 
-  it "should not call Factory.create when building an association" do
-    stub(FactoryGirl).create
-    @proxy.association(:user).should be_nil
-    FactoryGirl.should have_received.create.never
-  end
+  context "after associating a factory" do
+    let(:attribute) { :owner }
 
-  it "should always return nil when building an association" do
-    @proxy.set(:association, 'x')
-    @proxy.association(:user).should be_nil
-  end
+    before { subject.associate(attribute, :user, {}) }
 
-  it "should return a hash when asked for the result" do
-    @proxy.result(nil).should be_kind_of(Hash)
+    it "doesn't set that key in the resulting hash" do
+      subject.result(nil).should_not have_key(attribute)
+    end
+
+    it "returns nil when asked for that attribute" do
+      subject.get(attribute).should be_nil
+    end
   end
 
   describe "after setting an attribute" do
-    before do
-      @proxy.set(:attribute, 'value')
-    end
+    let(:attribute) { :attribute }
+    let(:value)     { "value" }
+
+    before { subject.set(attribute, value) }
 
-    it "should set that value in the resulting hash" do
-      @proxy.result(nil)[:attribute].should == 'value'
+    it "sets that value in the resulting hash" do
+      subject.result(nil)[attribute].should == value
     end
 
-    it "should return that value when asked for that attribute" do
-      @proxy.get(:attribute).should == 'value'
+    it "returns that value when asked for that attribute" do
+      subject.get(attribute).should == value
     end
   end
 end

data/spec/factory_girl/proxy/build_spec.rb

@@ -1,86 +1,12 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::Build do
-  before do
-    @class       = Class.new
-    @instance    = "built-instance"
+  let(:instance)    { stub("built-instance") }
+  let(:proxy_class) { stub("class", :new => instance) }
 
-    stub(@class).new { @instance }
-    stub(@instance).attribute { 'value' }
-    stub(@instance, :attribute=)
-    stub(@instance, :owner=)
+  subject { FactoryGirl::Proxy::Build.new(proxy_class) }
 
-    @proxy = FactoryGirl::Proxy::Build.new(@class)
-  end
-
-  it "should instantiate the class" do
-    @class.should have_received.new
-  end
-
-  describe "when asked to associate with another factory" do
-    before do
-      @association = "associated-instance"
-      @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
-      stub(@associated_factory).run { @association }
-      @overrides = { 'attr' => 'value' }
-      @proxy.associate(:owner, :user, @overrides)
-    end
-
-    it "should create the associated instance" do
-      @associated_factory.should have_received.run(FactoryGirl::Proxy::Create, @overrides)
-    end
-
-    it "should set the associated instance" do
-      @instance.should have_received.method_missing(:owner=, @association)
-    end
-  end
-
-  it "should run create when building an association" do
-    association = "associated-instance"
-    associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
-    stub(associated_factory).run { association }
-    overrides = { 'attr' => 'value' }
-    @proxy.association(:user, overrides).should == association
-    associated_factory.should have_received.run(FactoryGirl::Proxy::Create, overrides)
-  end
-
-  it "should return the built instance when asked for the result" do
-    @proxy.result(nil).should == @instance
-  end
-
-  it "should run the :after_build callback when retrieving the result" do
-    spy = Object.new
-    stub(spy).foo
-    @proxy.add_callback(:after_build, proc{ spy.foo })
-    @proxy.result(nil)
-    spy.should have_received.foo
-  end
-
-  describe "when setting an attribute" do
-    before do
-      stub(@instance).attribute = 'value'
-      @proxy.set(:attribute, 'value')
-    end
-
-    it "should set that value" do
-      @instance.should have_received.method_missing(:attribute=, 'value')
-    end
-  end
-
-  describe "when getting an attribute" do
-    before do
-      @result = @proxy.get(:attribute)
-    end
-
-    it "should ask the built class for the value" do
-      @instance.should have_received.attribute
-    end
-
-    it "should return the value for that attribute" do
-      @result.should == 'value'
-    end
-  end
+  it_should_behave_like "proxy with association support", FactoryGirl::Proxy::Create
+  it_should_behave_like "proxy with standard getters and setters", :attribute_name, "attribute value!"
+  it_should_behave_like "proxy with callbacks", :after_build
 end
-

data/spec/factory_girl/proxy/create_spec.rb

@@ -1,107 +1,42 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::Create do
-  before do
-    @class       = Class.new
-    @instance    = "built-instance"
 
-    stub(@class).new { @instance }
-    stub(@instance).attribute { 'value' }
-    stub(@instance, :attribute=)
-    stub(@instance, :owner=)
-    stub(@instance).save!
+  let(:instance)    { stub("created-instance", :save! => true) }
+  let(:proxy_class) { stub("class", :new => instance) }
 
-    @proxy = FactoryGirl::Proxy::Create.new(@class)
-  end
-
-  it "should instantiate the class" do
-    @class.should have_received.new
-  end
+  subject { FactoryGirl::Proxy::Create.new(proxy_class) }
 
-  describe "when asked to associate with another factory" do
-    before do
-      @association = "associated-instance"
-      @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
-      stub(@associated_factory).run { @association }
-      @overrides = { 'attr' => 'value' }
-      @proxy.associate(:owner, :user, @overrides)
-    end
+  it_should_behave_like "proxy with association support", FactoryGirl::Proxy::Create
+  it_should_behave_like "proxy with standard getters and setters", :attribute_name, "attribute value!"
+  it_should_behave_like "proxy with callbacks", :after_build
+  it_should_behave_like "proxy with callbacks", :after_create
 
-    it "should create the associated instance" do
-      @associated_factory.should have_received.run(FactoryGirl::Proxy::Create, @overrides)
-    end
-
-    it "should set the associated instance" do
-      @instance.should have_received.method_missing(:owner=, @association)
-    end
-  end
-
-  it "should run create when building an association" do
-    association = "associated-instance"
-    associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
-    stub(associated_factory).run { association }
-    overrides = { 'attr' => 'value' }
-    @proxy.association(:user, overrides).should == association
-    associated_factory.should have_received.run(FactoryGirl::Proxy::Create, overrides)
-  end
-
-  describe "when asked for the result" do
-    before do
-      @build_spy = Object.new
-      @create_spy = Object.new
-      stub(@build_spy).foo
-      stub(@create_spy).foo
-      @proxy.add_callback(:after_build,  proc{ @build_spy.foo })
-      @proxy.add_callback(:after_create, proc{ @create_spy.foo })
-      @result = @proxy.result(nil)
-    end
-
-    it "should save the instance" do
-      @instance.should have_received.save!
-    end
-
-    it "should return the built instance" do
-      @result.should == @instance
-    end
-
-    it "should run both the build and the create callbacks" do
-      @build_spy.should have_received.foo
-      @create_spy.should have_received.foo
-    end
+  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 = 'custom create block'
-    stub(block).call
-    stub(@instance).save! { raise }
-    instance = @proxy.result(block)
-    block.should have_received.call(instance)
+    block = stub('custom create block', :call => nil)
+    subject.result(block)
+    block.should have_received(:call).with(instance)
+    instance.should have_received(:save!).never
   end
 
-  describe "when setting an attribute" do
-    before do
-      @proxy.set(:attribute, 'value')
-    end
-
-    it "should set that value" do
-      @instance.should have_received.method_missing(:attribute=, 'value')
-    end
-  end
+  context "callback execution order" do
+    let(:after_build_callback)  { stub("after_build callback", :foo => nil) }
+    let(:after_create_callback) { stub("after_create callback", :foo => nil) }
+    let(:callback_sequence)     { sequence("after_* callbacks") }
 
-  describe "when getting an attribute" do
-    before do
-      @result = @proxy.get(:attribute)
-    end
+    it "runs after_build callbacks before after_create callbacks" do
+      subject.add_callback(:after_build,  proc { after_build_callback.foo })
+      subject.add_callback(:after_create, proc { after_create_callback.foo })
 
-    it "should ask the built class for the value" do
-      @instance.should have_received.attribute
-    end
+      after_build_callback.expects(:foo).once.in_sequence(callback_sequence)
+      after_create_callback.expects(:foo).once.in_sequence(callback_sequence)
 
-    it "should return the value for that attribute" do
-      @result.should == 'value'
+      subject.result(nil)
     end
   end
 end
-

data/spec/factory_girl/proxy/stub_spec.rb

@@ -1,84 +1,25 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::Stub do
-  before do
-    @class = "class"
-    @instance = "instance"
-    stub(@class).new { @instance }
-    stub(@instance, :id=)
-    stub(@instance).id { 42 }
-    stub(@instance).reload { @instance.connection.reload }
+  let(:instance)    { stub("instance", :id= => nil, :id => 42) }
+  let(:proxy_class) { stub("class", :new => instance) }
 
-    @stub = FactoryGirl::Proxy::Stub.new(@class)
-  end
-
-  it "should not be a new record" do
-    @stub.result(nil).should_not be_new_record
-  end
-
-  it "should be persisted" do
-    @stub.result(nil).should be_persisted
-  end
-
-  it "should not be able to connect to the database" do
-    lambda { @stub.result(nil).reload }.should raise_error(RuntimeError)
-  end
-
-  describe "when a user factory exists" do
-    before do
-      @user = "user"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
-      @associated_factory = 'associate-factory'
-    end
-
-    describe "when asked to associate with another factory" do
-      before do
-        stub(@instance).owner { @user }
-        mock(@associated_factory).run(FactoryGirl::Proxy::Stub, {}) { @user }
-        mock(@stub).set(:owner, @user)
-
-        @stub.associate(:owner, :user, {})
-      end
+  subject { FactoryGirl::Proxy::Stub.new(proxy_class) }
 
-      it "should set a value for the association" do
-        @stub.result(nil).owner.should == @user
-      end
-    end
-
-    it "should return the association when building one" do
-      mock(@associated_factory).run(FactoryGirl::Proxy::Stub, {}) { @user }
-      @stub.association(:user).should == @user
-    end
+  it_should_behave_like "proxy with association support", FactoryGirl::Proxy::Stub
+  it_should_behave_like "proxy with standard getters and setters", :attribute_name, "attribute value!"
+  it_should_behave_like "proxy with callbacks", :after_stub
 
-    describe "when asked for the result" do
-      it "should return the actual instance" do
-        @stub.result(nil).should == @instance
-      end
+  context "asking for a result" do
+    it { subject.result(nil).should_not be_new_record }
+    it { subject.result(nil).should be_persisted }
 
-      it "should run the :after_stub callback" do
-        @spy = Object.new
-        stub(@spy).foo
-        @stub.add_callback(:after_stub, proc{ @spy.foo })
-        @stub.result(nil)
-        @spy.should have_received.foo
+    [:save, :destroy, :connection, :reload, :update_attribute].each do |database_method|
+      it "raises when attempting to connect to the database by calling #{database_method}" do
+        expect do
+          subject.result(nil).send(database_method)
+        end.to raise_error(RuntimeError, "stubbed models are not allowed to access the database")
       end
     end
   end
-
-  describe "with an existing attribute" do
-    before do
-      @value = "value"
-      mock(@instance).send(:attribute) { @value }
-      mock(@instance).send(:attribute=, @value)
-      @stub.set(:attribute, @value)
-    end
-
-    it "should to the resulting object" do
-      @stub.attribute.should == 'value'
-    end
-
-    it "should return that value when asked for that attribute" do
-      @stub.get(:attribute).should == @value
-    end
-  end
 end

data/spec/factory_girl/proxy_spec.rb

@@ -1,84 +1,84 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy do
-  before do
-    @proxy = FactoryGirl::Proxy.new(Class.new)
-  end
+  subject { FactoryGirl::Proxy.new(Class.new) }
 
-  it "should do nothing when asked to set an attribute to a value" do
-    lambda { @proxy.set(:name, 'a name') }.should_not raise_error
-  end
+  it_should_behave_like "proxy without association support"
 
-  it "should return nil when asked for an attribute" do
-    @proxy.get(:name).should be_nil
+  it "doesn't raise when assigning a value to an attribute" do
+    expect { subject.set(:name, "a name") }.to_not raise_error
   end
 
-  it "should call get for a missing method" do
-    mock(@proxy).get(:name) { "it's a name" }
-    @proxy.name.should == "it's a name"
+  it "returns nil for an attribute without a value" do
+    subject.get(:name).should be_nil
   end
 
-  it "should do nothing when asked to associate with another factory" do
-    lambda { @proxy.associate(:owner, :user, {}) }.should_not raise_error
+  it "calls get for a missing method" do
+    subject.stubs(:get).with(:name).returns("it's a name")
+    subject.name.should == "it's a name"
   end
 
-  it "should raise an error when asked for the result" do
-    lambda { @proxy.result(nil) }.should raise_error(NotImplementedError)
+  it "raises an error when asking for the result" do
+    expect { subject.result(nil) }.to raise_error(NotImplementedError)
   end
 
   describe "when adding callbacks" do
-    before do
-      @first_block  = proc{ 'block 1' }
-      @second_block = proc{ 'block 2' }
-    end
-    it "should add a callback" do
-      @proxy.add_callback(:after_create, @first_block)
-      @proxy.callbacks[:after_create].should be_eql([@first_block])
+    let(:block_1) { proc { "block 1" } }
+    let(:block_2) { proc { "block 2" } }
+
+    it "adds a callback" do
+      subject.add_callback(:after_create, block_1)
+      subject.callbacks[:after_create].should be_eql([block_1])
     end
 
-    it "should add multiple callbacks of the same name" do
-      @proxy.add_callback(:after_create, @first_block)
-      @proxy.add_callback(:after_create, @second_block)
-      @proxy.callbacks[:after_create].should be_eql([@first_block, @second_block])
+    it "adds multiple callbacks of the same name" do
+      subject.add_callback(:after_create, block_1)
+      subject.add_callback(:after_create, block_2)
+      subject.callbacks[:after_create].should be_eql([block_1, block_2])
     end
 
-    it "should add multiple callbacks of different names" do
-      @proxy.add_callback(:after_create, @first_block)
-      @proxy.add_callback(:after_build,  @second_block)
-      @proxy.callbacks[:after_create].should be_eql([@first_block])
-      @proxy.callbacks[:after_build].should be_eql([@second_block])
+    it "adds multiple callbacks with different names" do
+      subject.add_callback(:after_create, block_1)
+      subject.add_callback(:after_build,  block_2)
+      subject.callbacks[:after_create].should be_eql([block_1])
+      subject.callbacks[:after_build].should be_eql([block_2])
     end
   end
 
   describe "when running callbacks" do
-    before do
-      @first_spy = Object.new
-      @second_spy = Object.new
-      stub(@first_spy).foo
-      stub(@second_spy).foo
+    let(:object_1_within_callback) { stub("call_in_create", :foo => true) }
+    let(:object_2_within_callback) { stub("call_in_create", :foo => true) }
+
+    it "runs all callbacks with a given name" do
+      subject.add_callback(:after_create, proc { object_1_within_callback.foo })
+      subject.add_callback(:after_create, proc { object_2_within_callback.foo })
+      subject.run_callbacks(:after_create)
+      object_1_within_callback.should have_received(:foo).once
+      object_2_within_callback.should have_received(:foo).once
     end
 
-    it "should run all callbacks with a given name" do
-      @proxy.add_callback(:after_create, proc{ @first_spy.foo })
-      @proxy.add_callback(:after_create, proc{ @second_spy.foo })
-      @proxy.run_callbacks(:after_create)
-      @first_spy.should have_received.foo
-      @second_spy.should have_received.foo
+    it "only runs callbacks with a given name" do
+      subject.add_callback(:after_create, proc { object_1_within_callback.foo })
+      subject.add_callback(:after_build,  proc { object_2_within_callback.foo })
+      subject.run_callbacks(:after_create)
+      object_1_within_callback.should have_received(:foo).once
+      object_2_within_callback.should have_received(:foo).never
     end
 
-    it "should only run callbacks with a given name" do
-      @proxy.add_callback(:after_create, proc{ @first_spy.foo })
-      @proxy.add_callback(:after_build,  proc{ @second_spy.foo })
-      @proxy.run_callbacks(:after_create)
-      @first_spy.should have_received.foo
-      @second_spy.should_not have_received.foo
+    it "passes in the instance if the block takes an argument" do
+      subject.instance_variable_set("@instance", object_1_within_callback)
+      subject.add_callback(:after_create, proc {|spy| spy.foo })
+      subject.run_callbacks(:after_create)
+      object_1_within_callback.should have_received(:foo).once
     end
 
-    it "should pass in the instance if the block takes an argument" do
-      @proxy.instance_variable_set("@instance", @first_spy)
-      @proxy.add_callback(:after_create, proc{|spy| spy.foo })
-      @proxy.run_callbacks(:after_create)
-      @first_spy.should have_received.foo
+    it "passes in the instance and the proxy if the block takes two arguments" do
+      subject.instance_variable_set("@instance", object_1_within_callback)
+      proxy_instance = nil
+      subject.add_callback(:after_create, proc {|spy, proxy| spy.foo; proxy_instance = proxy })
+      subject.run_callbacks(:after_create)
+      object_1_within_callback.should have_received(:foo).once
+      proxy_instance.should == subject
     end
   end
 end