From d3d3dd042b1ef6a58f83c893d526f1b52bff1ece Mon Sep 17 00:00:00 2001 From: Joe Ferris Date: Fri, 2 Jan 2009 13:40:57 -0500 Subject: [PATCH] Cleaned up some factory tests --- lib/factory_girl/factory.rb | 12 +-- test/factory_test.rb | 151 ++++++++++++++++++++---------------- 2 files changed, 91 insertions(+), 72 deletions(-) diff --git a/lib/factory_girl/factory.rb b/lib/factory_girl/factory.rb index 51c1ede..01d93af 100644 --- a/lib/factory_girl/factory.rb +++ b/lib/factory_girl/factory.rb @@ -191,12 +191,6 @@ class Factory end end - private - - def self.factory_by_name (name) - factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}") - end - def run_strategy (strategy_class, overrides) strategy = strategy_class.new(build_class) overrides = symbolize_keys(overrides) @@ -210,6 +204,12 @@ class Factory strategy.result end + private + + def self.factory_by_name (name) + factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}") + end + def class_for (class_or_to_s) if class_or_to_s.respond_to?(:to_sym) Object.const_get(variable_name_to_class_name(class_or_to_s)) diff --git a/test/factory_test.rb b/test/factory_test.rb index 739bfaa..2b478d0 100644 --- a/test/factory_test.rb +++ b/test/factory_test.rb @@ -70,15 +70,53 @@ class FactoryTest < Test::Unit::TestCase end end - context "when adding an attribute with a value parameter" do + should "create a new attribute when an attribute is defined" do + block = lambda {} + attribute = mock('attribute', :name => :name) + Factory::Attribute. + expects(:new). + with(:name, 'value', block). + returns(attribute) + @factory.add_attribute(:name, 'value', &block) + end + + context "after adding an attribute" do setup do - @attr = :name - @value = 'Elvis lives!' - @factory.add_attribute(@attr, @value) + @attribute = mock('attribute') + @strategy = mock('strategy') + + @attribute. stubs(:name). returns(:name) + @attribute. stubs(:value). returns('value') + @strategy. stubs(:set) + @strategy. stubs(:result).returns('result') + Factory::Attribute. stubs(:new). returns(@attribute) + Factory::Strategy::Build.stubs(:new). returns(@strategy) + + @factory.add_attribute(:name, 'value') end - should "include that value in the generated attributes hash" do - assert_equal @value, @factory.attributes_for[@attr] + should "create the right strategy using the build class when running" do + Factory::Strategy::Build. + expects(:new). + with(@factory.build_class). + returns(@strategy) + @factory.run_strategy(Factory::Strategy::Build, {}) + end + + should "get the value from the attribute when running" do + @attribute.expects(:value).with(@strategy).returns('value') + @factory.run_strategy(Factory::Strategy::Build, {}) + end + + should "set the value on the strategy when running" do + @strategy.expects(:set).with(:name, 'value') + @factory.run_strategy(Factory::Strategy::Build, {}) + end + + should "return the result from the strategy when running" do + @strategy.expects(:result).with().returns('result') + assert_equal 'result', + @factory.run_strategy(Factory::Strategy::Build, {}) end end @@ -90,41 +128,6 @@ class FactoryTest < Test::Unit::TestCase Factory::AttributeProxy.stubs(:new).returns(@proxy) end - should "not evaluate the block when the attribute is added" do - @factory.add_attribute(@attr) { flunk } - end - - should "evaluate the block when attributes are generated" do - called = false - @factory.add_attribute(@attr) do - called = true - end - @factory.attributes_for - assert called - end - - should "use the result of the block as the value of the attribute" do - value = "Watch out for snakes!" - @factory.add_attribute(@attr) { value } - assert_equal value, @factory.attributes_for[@attr] - end - - should "build an attribute proxy" do - Factory::AttributeProxy. - expects(:new). - with(is_a(Factory::Strategy)). - returns(@proxy) - @factory.add_attribute(@attr) {} - @factory.attributes_for - end - - should "yield an attribute proxy to the block" do - yielded = nil - @factory.add_attribute(@attr) {|y| yielded = y } - @factory.attributes_for - assert_equal @proxy, yielded - end - context "when other attributes have previously been defined" do setup do @attr = :unimportant @@ -361,31 +364,53 @@ class FactoryTest < Test::Unit::TestCase end end - context "Factory class" do + context "after defining a factory" do setup do - @name = :user - @attrs = { :last_name => 'Override' } - @first_name = 'Johnny' - @last_name = 'Winter' - @class = User - - Factory.define(@name) do |u| - u.first_name @first_name - u.last_name { @last_name } - u.email 'jwinter@guitar.org' + @name = :user + Factory.define(@name) do |f| + f.first_name 'First' + f.last_name 'Last' + f.email 'name@example.com' end - @factory = Factory.factories[@name] end + teardown { Factory.factories.clear } + + should "use Strategy::AttributesFor for Factory.attributes_for" do + @factory. + expects(:run_strategy). + with(Factory::Strategy::AttributesFor, :attr => 'value'). + returns('result') + assert_equal 'result', Factory.attributes_for(@name, :attr => 'value') + end + + should "use Strategy::Build for Factory.build" do + @factory. + expects(:run_strategy). + with(Factory::Strategy::Build, :attr => 'value'). + returns('result') + assert_equal 'result', Factory.build(@name, :attr => 'value') + end + + should "use Strategy::Create for Factory.create" do + @factory. + expects(:run_strategy). + with(Factory::Strategy::Create, :attr => 'value'). + returns('result') + assert_equal 'result', Factory.create(@name, :attr => 'value') + end + + should "use Strategy::Create for the global Factory method" do + @factory. + expects(:run_strategy). + with(Factory::Strategy::Create, :attr => 'value'). + returns('result') + assert_equal 'result', Factory(@name, :attr => 'value') + end + [:build, :create, :attributes_for].each do |method| - - should "delegate the #{method} method to the factory instance" do - @factory.expects(method).with(@attrs) - Factory.send(method, @name, @attrs) - end - - should "raise an ArgumentError when #{method} is called with a nonexistant factory" do + should "raise an ArgumentError on #{method} with a nonexistant factory" do assert_raise(ArgumentError) { Factory.send(method, :bogus) } end @@ -393,12 +418,6 @@ class FactoryTest < Test::Unit::TestCase assert_nothing_raised { Factory.send(method, @name.to_s) } assert_nothing_raised { Factory.send(method, @name.to_sym) } end - - end - - should "call the create method from the top-level Factory() method" do - @factory.expects(:create).with(@attrs) - Factory(@name, @attrs) end end