Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Rework more tests to allow for attribute_list refactoring

  • Loading branch information...
commit 2b4a6c72c84a272b03cb718d0353dc252e8db06a 1 parent 744177c
@joshuaclayton joshuaclayton authored
View
192 spec/factory_girl/definition_proxy_spec.rb
@@ -66,98 +66,140 @@
subject.sequence(:name, "A") {}
FactoryGirl::Sequence.should have_received(:new).with(:name, "A")
end
+ end
- it "should add a dynamic attribute" do
- attribute = stub('attribute', :name => :name)
- FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
- subject.sequence(:name) {}
- factory.attributes.should include(attribute)
- FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, is_a(Proc))
+ it "adds an implicit attribute when passed an undefined method without arguments or a block" do
+ factory.stubs(:define_attribute)
+ attribute = stub('attribute', :name => :name)
+ FactoryGirl::Attribute::Implicit.stubs(:new => attribute)
+ subject.send(:name)
+ FactoryGirl::Attribute::Implicit.should have_received(:new).with(:name, factory)
+ factory.should have_received(:define_attribute).with(attribute)
+ end
+end
+
+describe FactoryGirl::DefinitionProxy, "with a factory mock" do
+ before do
+ define_class("FactoryMock") do
+ def add_callback(callback, &block)
+ [callback, block.call]
+ end
+
+ def to_create(&block)
+ block.call
+ end
end
end
- it "should add a callback attribute when the after_build attribute is defined" do
- FactoryGirl::Attribute::Callback.stubs(:new => "after_build callback")
- subject.after_build {}
- factory.attributes.should include('after_build callback')
- FactoryGirl::Attribute::Callback.should have_received(:new).with(:after_build, is_a(Proc))
+ let(:factory_mock) { FactoryMock.new }
+ subject { FactoryGirl::DefinitionProxy.new(factory_mock) }
+
+ it "defines after_build callbacks" do
+ subject.after_build { "after_build value" }.should == [:after_build, "after_build value"]
end
- it "should add a callback attribute when the after_create attribute is defined" do
- FactoryGirl::Attribute::Callback.stubs(:new => "after_create callback")
- subject.after_create {}
- factory.attributes.should include('after_create callback')
- FactoryGirl::Attribute::Callback.should have_received(:new).with(:after_create, is_a(Proc))
+ it "defines after_create callbacks" do
+ subject.after_create { "after_create value" }.should == [:after_create, "after_create value"]
end
- it "should add a callback attribute when the after_stub attribute is defined" do
- FactoryGirl::Attribute::Callback.stubs(:new => "after_stub callback")
- subject.after_stub {}
- factory.attributes.should include('after_stub callback')
- FactoryGirl::Attribute::Callback.should have_received(:new).with(:after_stub, is_a(Proc))
+ it "defines after_stub callbacks" do
+ subject.after_stub { "after_stub value" }.should == [:after_stub, "after_stub value"]
end
- it "should add an association without a factory name or overrides" do
- name = :user
- attr = stub('attribute', :name => name)
- FactoryGirl::Attribute::Association.stubs(:new => attr)
- subject.association(name)
- factory.attributes.should include(attr)
- FactoryGirl::Attribute::Association.should have_received(:new).with(name, name, {})
+ it "defines to_create" do
+ subject.to_create { "to_create value" }.should == "to_create value"
end
+end
- it "should add an association with overrides" do
- name = :user
- attr = stub('attribute', :name => name)
- overrides = { :first_name => 'Ben' }
- FactoryGirl::Attribute::Association.stubs(:new => attr)
- subject.association(name, overrides)
- factory.attributes.should include(attr)
- FactoryGirl::Attribute::Association.should have_received(:new).with(name, name, overrides)
+describe FactoryGirl::DefinitionProxy, "adding attributes" do
+ let(:factory) { FactoryGirl::Factory.new(:object) }
+ subject { FactoryGirl::DefinitionProxy.new(factory) }
+ let(:attribute) { stub("created attribute") }
+ let(:block) { lambda { } }
+ let(:attribute_name) { :full_name }
+ let(:attribute_value) { "passed value" }
+
+ before { factory.stubs(:define_attribute) }
+
+ context "when a block is passed" do
+ before { FactoryGirl::Attribute::Dynamic.stubs(:new => attribute) }
+
+ it "creates a dynamic attribute" do
+ subject.add_attribute(attribute_name, &block)
+ FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+ factory.should have_received(:define_attribute).with(attribute)
+ end
+
+ it "creates a dynamic attribute without the method being defined" do
+ subject.send(attribute_name, &block)
+ FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+ factory.should have_received(:define_attribute).with(attribute)
+ end
end
- it "should add an attribute using the method name when passed an undefined method" do
- attribute = stub('attribute', :name => :name)
- FactoryGirl::Attribute::Static.stubs(:new => attribute)
- subject.send(:name, 'value')
- factory.attributes.should include(attribute)
- FactoryGirl::Attribute::Static.should have_received(:new).with(:name, 'value')
+ context "when a value is passed" do
+ before { FactoryGirl::Attribute::Static.stubs(:new => attribute) }
+
+ it "creates a static attribute" do
+ subject.add_attribute(attribute_name, attribute_value)
+ FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+ factory.should have_received(:define_attribute).with(attribute)
+ end
+
+ it "creates a static attribute without the method being defined" do
+ subject.send(attribute_name, attribute_value)
+ FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+ factory.should have_received(:define_attribute).with(attribute)
+ end
end
- it "adds an attribute using when passed an undefined method and block" do
- attribute = stub('attribute', :name => :name)
- block = lambda {}
- FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
- subject.send(:name, &block)
- factory.attributes.should include(attribute)
- FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, block)
+ context "when a block and value are passed" do
+ it "raises an exception" do
+ expect do
+ subject.add_attribute(attribute_name, attribute_value) { "block" }
+ end.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
+ end
end
+end
- it "adds an implicit attribute when passed an undefined method without arguments or a block" do
- name = :user
- attr = stub('attribute', :name => name)
- FactoryGirl::Attribute::Implicit.stubs(:new => attr)
- subject.send(name)
- factory.attributes.should include(attr)
- FactoryGirl::Attribute::Implicit.should have_received(:new).with(name, factory)
- end
-
- it "adds an association when passed an undefined method with a hash including :factory key" do
- name = :author
- factory_name = :user
- overrides = { :first_name => 'Ben' }
- args = { :factory => factory_name }.merge(overrides)
- attr = stub('attribute', :name => name)
- FactoryGirl::Attribute::Association.stubs(:new => attr)
- subject.send(name, args)
- factory.attributes.should include(attr)
- FactoryGirl::Attribute::Association.should have_received(:new).with(name, factory_name, overrides)
- end
-
- it "delegates to_create" do
- result = 'expected'
- factory.stubs(:to_create => result)
- subject.to_create.should == result
- factory.should have_received(:to_create)
+describe FactoryGirl::DefinitionProxy, "#association" do
+ let(:factory) { FactoryGirl::Factory.new(:object) }
+ subject { FactoryGirl::DefinitionProxy.new(factory) }
+ let(:attribute) { stub("attribute") }
+ let(:association_name) { :author }
+ let(:factory_name) { :user }
+
+ before do
+ FactoryGirl::Attribute::Association.stubs(:new => attribute)
+ factory.stubs(:define_attribute)
+ end
+
+ context "with a factory set in the hash" do
+ let(:options) { { :factory => factory_name, :name => "John Doe" } }
+
+ it "defines an association attribute with the factory name" do
+ subject.association(association_name, options)
+
+ factory.should have_received(:define_attribute).with(attribute)
+ FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
+ end
+
+ it "defines an association attribute when the association is called implicitly" do
+ subject.send(association_name, options)
+
+ factory.should have_received(:define_attribute).with(attribute)
+ FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
+ end
+ end
+
+ context "without a factory set in the hash" do
+ let(:options) { { :name => "Jane Doe" } }
+
+ it "defines an association attribute with the association name" do
+ subject.association(association_name, options)
+
+ factory.should have_received(:define_attribute).with(attribute)
+ FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, association_name, options)
+ end
end
end
View
58 spec/factory_girl/factory_spec.rb
@@ -23,36 +23,6 @@
@factory.default_strategy.should == :create
end
- describe "after adding an attribute" do
- before do
- @attribute = stub("attribute", :name => :name, :add_to => nil)
- @proxy = stub("proxy", :result => "result", :set => nil)
-
- FactoryGirl::Attribute::Static.stubs(:new => @attribute)
- FactoryGirl::Proxy::Build.stubs(:new => @proxy)
-
- @factory.define_attribute(@attribute)
- end
-
- it "should create the right proxy using the build class when running" do
- FactoryGirl::Proxy::Build.stubs(:new => @proxy)
- @factory.run(FactoryGirl::Proxy::Build, {})
- FactoryGirl::Proxy::Build.should have_received(:new).with(@factory.build_class)
- end
-
- it "should add the attribute to the proxy when running" do
- @attribute.stubs(:add_to)
- @factory.run(FactoryGirl::Proxy::Build, {})
- @attribute.should have_received(:add_to).with(@proxy)
- end
-
- it "should return the result from the proxy when running" do
- @proxy.stubs(:result => "result")
- @factory.run(FactoryGirl::Proxy::Build, {}).should == 'result'
- @proxy.should have_received(:result).with(nil)
- end
- end
-
it "passes a custom creation block" do
proxy = stub("proxy", :result => nil)
FactoryGirl::Proxy::Build.stubs(:new => proxy)
@@ -336,3 +306,31 @@
its(:human_names) { should == ["happy user", "gleeful user", "person"] }
end
end
+
+describe FactoryGirl::Factory, "running a factory" do
+ subject { FactoryGirl::Factory.new(:user) }
+ let(:attribute) { stub("attribute", :name => :name, :add_to => nil) }
+ let(:proxy) { stub("proxy", :result => "result", :set => nil) }
+
+ before do
+ define_class("User")
+ FactoryGirl::Attribute::Static.stubs(:new => attribute)
+ FactoryGirl::Proxy::Build.stubs(:new => proxy)
+ FactoryGirl::AttributeList.stubs(:new => [attribute])
+ 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)
+ end
+
+ it "returns the result from the proxy when running" do
+ subject.run(FactoryGirl::Proxy::Build, {}).should == "result"
+ proxy.should have_received(:result).with(nil)
+ end
+end
Please sign in to comment.
Something went wrong with that request. Please try again.