factory_girl 1.1.2 → 1.1.3

data/Changelog

@@ -1,3 +1,6 @@
+1.1.3 (September 12, 2008)
+  Automatically pull in definitions from factories.rb, test/factories.rb, or
+	spec/factories.rb
 1.1.2 (July 30, 2008)
   Improved error handling for invalid and undefined factories/attributes
 	Improved handling of strings vs symbols vs classes

data/Rakefile

@@ -31,7 +31,7 @@ end
 
 spec = Gem::Specification.new do |s|
   s.name        = %q{factory_girl}
-  s.version     = "1.1.2"
+  s.version     = "1.1.3"
   s.summary     = %q{factory_girl provides a framework and DSL for defining and
                      using model instance factories.}
   s.description = %q{factory_girl provides a framework and DSL for defining and

data/lib/factory_girl.rb

@@ -1,7 +1,9 @@
 require 'active_support'
 require 'factory_girl/factory'
 require 'factory_girl/attribute_proxy'
+require 'factory_girl/attribute'
 require 'factory_girl/sequence'
+require 'factory_girl/aliases'
 
 # Shortcut for Factory.create.
 #
@@ -10,3 +12,5 @@ require 'factory_girl/sequence'
 def Factory (name, attrs = {})
   Factory.create(name, attrs)
 end
+
+Factory.find_definitions

data/lib/factory_girl/aliases.rb

@@ -0,0 +1,37 @@
+class Factory
+
+  cattr_accessor :aliases #:nodoc:
+  self.aliases = [
+    [/(.*)_id/, '\1'],
+    [/(.*)/, '\1_id']
+  ]
+
+  # Defines a new alias for attributes
+  #
+  # Arguments:
+  #   pattern: (Regexp)
+  #     A pattern that will be matched against attributes when looking for
+  #     aliases. Contents captured in the pattern can be used in the alias.
+  #   replace: (String)
+  #     The alias that results from the matched pattern. Captured strings can
+  #     be insert like String#sub.
+  #
+  # Example:
+  #   
+  #   Factory.alias /(.*)_confirmation/, '\1'
+  def self.alias (pattern, replace)
+    self.aliases << [pattern, replace]
+  end
+
+  def self.aliases_for (attribute) #:nodoc:
+    aliases.collect do |params|
+      pattern, replace = *params
+      if pattern.match(attribute.to_s)
+        attribute.to_s.sub(pattern, replace).to_sym
+      else
+        nil
+      end
+    end.compact << attribute
+  end
+
+end

data/lib/factory_girl/attribute.rb

@@ -0,0 +1,38 @@
+class Factory
+
+  class AttributeDefinitionError < RuntimeError
+  end
+  
+  class Attribute #:nodoc:
+
+    attr_reader :name
+
+    def initialize (name, static_value, lazy_block)
+      name = name.to_sym
+
+      if name.to_s =~ /=$/
+        raise AttributeDefinitionError, 
+          "factory_girl uses 'f.#{name.to_s.chop} value' syntax " +
+          "rather than 'f.#{name} = value'" 
+      end
+
+      unless static_value.nil? || lazy_block.nil?
+        raise AttributeDefinitionError, "Both value and block given"
+      end
+
+      @name         = name
+      @static_value = static_value
+      @lazy_block   = lazy_block
+    end
+
+    def value (proxy)
+      if @lazy_block.nil?
+        @static_value
+      else
+        @lazy_block.call(proxy)
+      end
+    end
+
+  end
+
+end

data/lib/factory_girl/factory.rb

@@ -1,11 +1,14 @@
 class Factory
   
-  class AttributeDefinitionError < RuntimeError
-  end
-  
-  cattr_accessor :factories, :sequences #:nodoc:
+  cattr_accessor :factories #:nodoc:
   self.factories = {}
-  self.sequences = {}
+
+  # An Array of strings specifying locations that should be searched for
+  # factory definitions. By default, factory_girl will attempt to require
+  # "factories," "test/factories," and "spec/factories." Only the first
+  # existing file will be loaded.
+  cattr_accessor :definition_file_paths
+  self.definition_file_paths = %w(factories test/factories spec/factories)
 
   attr_reader :factory_name
 
@@ -28,41 +31,6 @@ class Factory
     self.factories[instance.factory_name] = instance
   end
 
-  # Defines a new sequence that can be used to generate unique values in a specific format.
-  #
-  # Arguments:
-  #   name: (Symbol)
-  #     A unique name for this sequence. This name will be referenced when
-  #     calling next to generate new values from this sequence.
-  #   block: (Proc)
-  #     The code to generate each value in the sequence. This block will be
-  #     called with a unique number each time a value in the sequence is to be
-  #     generated. The block should return the generated value for the
-  #     sequence.
-  #
-  # Example:
-  #   
-  #   Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
-  def self.sequence (name, &block)
-    self.sequences[name] = Sequence.new(&block)
-  end
-
-  # Generates and returns the next value in a sequence.
-  #
-  # Arguments:
-  #   name: (Symbol)
-  #     The name of the sequence that a value should be generated for.
-  #
-  # Returns:
-  #   The next value in the sequence. (Object)
-  def self.next (sequence)
-    unless self.sequences.key?(sequence)
-      raise "No such sequence: #{sequence}"
-    end
-
-    self.sequences[sequence].next
-  end
-
   def build_class #:nodoc:
     @build_class ||= class_for(@options[:class] || factory_name)
   end
@@ -71,10 +39,7 @@ class Factory
     options.assert_valid_keys(:class)
     @factory_name = factory_name_for(name)
     @options      = options
-
-    @static_attributes     = {}
-    @lazy_attribute_blocks = {}
-    @lazy_attribute_names  = []
+    @attributes   = []
   end
 
   # Adds an attribute that should be assigned on generated instances for this
@@ -96,23 +61,13 @@ class Factory
   #   value: (Object)
   #     If no block is given, this value will be used for this attribute.
   def add_attribute (name, value = nil, &block)
-    name = name.to_sym
+    attribute = Attribute.new(name, value, block)
 
-    if name.to_s =~ /=$/
-      raise AttributeDefinitionError, 
-        "factory_girl uses 'f.#{name.to_s.chop} #{value}' syntax " +
-        "rather than 'f.#{name} #{value}'" 
-    end
-    
-    if block_given?
-      unless value.nil?
-        raise ArgumentError, "Both value and block given"
-      end
-      @lazy_attribute_blocks[name] = block
-      @lazy_attribute_names << name
-    else
-      @static_attributes[name] = value
+    if attribute_defined?(attribute.name)
+      raise AttributeDefinitionError, "Attribute already defined: #{name}"
     end
+
+    @attributes << attribute
   end
 
   # Calls add_attribute using the missing method name as the name of the
@@ -225,6 +180,16 @@ class Factory
       factory_by_name(name).create(attrs)
     end
 
+    def find_definitions #:nodoc:
+      definition_file_paths.each do |path|
+        begin
+          require(path)
+          break
+        rescue LoadError
+        end
+      end
+    end
+
     private
 
     def factory_by_name (name)
@@ -235,14 +200,16 @@ class Factory
 
   private
 
-  def build_attributes_hash (override, strategy)
-    override = override.symbolize_keys
-    result = @static_attributes.merge(override)
-    @lazy_attribute_names.each do |name|
-      proxy = AttributeProxy.new(self, name, strategy, result)
-      result[name] = @lazy_attribute_blocks[name].call(proxy) unless override.key?(name)
+  def build_attributes_hash (values, strategy)
+    values = values.symbolize_keys
+    passed_keys = values.keys.collect {|key| Factory.aliases_for(key) }.flatten
+    @attributes.each do |attribute|
+      unless passed_keys.include?(attribute.name)
+        proxy = AttributeProxy.new(self, attribute.name, strategy, values)
+        values[attribute.name] = attribute.value(proxy)
+      end
     end
-    result
+    values
   end
 
   def build_instance (override, strategy)
@@ -270,4 +237,8 @@ class Factory
     end
   end
 
+  def attribute_defined? (name)
+    !@attributes.detect {|attr| attr.name == name }.nil?
+  end
+
 end

data/lib/factory_girl/sequence.rb

@@ -2,11 +2,12 @@ class Factory
 
   class Sequence
 
-    def initialize (&proc)
+    def initialize (&proc) #:nodoc:
       @proc  = proc
       @value = 0
     end
 
+    # Returns the next value for this sequence
     def next
       @value += 1
       @proc.call(@value)
@@ -14,4 +15,42 @@ class Factory
 
   end
 
+  cattr_accessor :sequences #:nodoc:
+  self.sequences = {}
+
+  # Defines a new sequence that can be used to generate unique values in a specific format.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name for this sequence. This name will be referenced when
+  #     calling next to generate new values from this sequence.
+  #   block: (Proc)
+  #     The code to generate each value in the sequence. This block will be
+  #     called with a unique number each time a value in the sequence is to be
+  #     generated. The block should return the generated value for the
+  #     sequence.
+  #
+  # Example:
+  #   
+  #   Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
+  def self.sequence (name, &block)
+    self.sequences[name] = Sequence.new(&block)
+  end
+
+  # Generates and returns the next value in a sequence.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     The name of the sequence that a value should be generated for.
+  #
+  # Returns:
+  #   The next value in the sequence. (Object)
+  def self.next (sequence)
+    unless self.sequences.key?(sequence)
+      raise "No such sequence: #{sequence}"
+    end
+
+    self.sequences[sequence].next
+  end
+
 end

data/test/aliases_test.rb

@@ -0,0 +1,29 @@
+require(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class AliasesTest < Test::Unit::TestCase
+
+  should "include an attribute as an alias for itself by default" do
+    assert Factory.aliases_for(:test).include?(:test)
+  end
+
+  should "include the root of a foreign key as an alias by default" do
+    assert Factory.aliases_for(:test_id).include?(:test)
+  end
+
+  should "include an attribute's foreign key as an alias by default" do
+    assert Factory.aliases_for(:test).include?(:test_id)
+  end
+
+  context "after adding an alias" do
+
+    setup do
+      Factory.alias(/(.*)_suffix/, '\1')
+    end
+
+    should "return the alias in the aliases list" do
+      assert Factory.aliases_for(:test_suffix).include?(:test)
+    end
+
+  end
+
+end

data/test/attribute_test.rb

@@ -0,0 +1,70 @@
+require(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class AttributeTest < Test::Unit::TestCase
+
+  def setup
+    @proxy = mock('attribute-proxy')
+  end
+
+  context "an attribute" do
+
+    setup do
+      @name  = :user
+      @attr  = Factory::Attribute.new(@name, 'test', nil)
+    end
+
+    should "have a name" do
+      assert_equal @name, @attr.name
+    end
+
+  end
+
+  context "an attribute with a static value" do
+
+    setup do
+      @value = 'test'
+      @attr  = Factory::Attribute.new(:user, @value, nil)
+    end
+
+    should "return the value" do
+      assert_equal @value, @attr.value(@proxy)
+    end
+
+  end
+
+  context "an attribute with a lazy value" do
+
+    setup do
+      @block = lambda { 'value' }
+      @attr  = Factory::Attribute.new(:user, nil, @block)
+    end
+
+    should "call the block to return a value" do
+      assert_equal 'value', @attr.value(@proxy)
+    end
+
+    should "yield the attribute proxy to the block" do
+      @block = lambda {|a| a }
+      @attr  = Factory::Attribute.new(:user, nil, @block)
+      assert_equal @proxy, @attr.value(@proxy)
+    end
+
+  end
+
+  should "raise an error when defining an attribute writer" do
+    assert_raise Factory::AttributeDefinitionError do
+      Factory::Attribute.new('test=', nil, nil)
+    end
+  end
+
+  should "not allow attributes to be added with both a value parameter and a block" do
+    assert_raise(Factory::AttributeDefinitionError) do
+      Factory::Attribute.new(:name, 'value', lambda {})
+    end
+  end
+
+  should "convert names to symbols" do
+    assert_equal :name, Factory::Attribute.new('name', nil, nil).name
+  end
+
+end

data/test/factory_test.rb

@@ -53,36 +53,6 @@ class FactoryTest < Test::Unit::TestCase
 
   end
   
-  should "raise an error when defining a factory when using attribute setters" do
-    assert_raise Factory::AttributeDefinitionError do
-      Factory.define(:user) do |f|
-        f.name = 'test'
-      end
-    end
-  end
-
-  context "defining a sequence" do
-
-    setup do
-      @sequence = mock('sequence')
-      @name     = :count
-      Factory::Sequence.stubs(:new).returns(@sequence)
-    end
-
-    should "create a new sequence" do
-      Factory::Sequence.expects(:new).with().returns(@sequence)
-      Factory.sequence(@name)
-    end
-
-    should "use the supplied block as the sequence generator" do
-      Factory::Sequence.stubs(:new).yields(1)
-      yielded = false
-      Factory.sequence(@name) {|n| yielded = true }
-      assert yielded
-    end
-
-  end
-
   context "a factory" do
 
     setup do
@@ -99,6 +69,12 @@ class FactoryTest < Test::Unit::TestCase
       assert_equal @class, @factory.build_class
     end
 
+    should "not allow the same attribute to be added twice" do
+      assert_raise(Factory::AttributeDefinitionError) do
+        2.times { @factory.add_attribute @name }
+      end
+    end
+
     context "when adding an attribute with a value parameter" do
 
       setup do
@@ -223,12 +199,6 @@ class FactoryTest < Test::Unit::TestCase
       assert_equal @value, @factory.attributes_for[@attr]
     end
 
-    should "not allow attributes to be added with both a value parameter and a block" do
-      assert_raise(ArgumentError) do
-        @factory.add_attribute(:name, 'value') {}
-      end
-    end
-
     should "allow attributes to be added with strings as names" do
       @factory.add_attribute('name', 'value')
       assert_equal 'value', @factory.attributes_for[:name]
@@ -260,6 +230,24 @@ class FactoryTest < Test::Unit::TestCase
 
     end
 
+    context "overriding an attribute with an alias" do
+
+      setup do
+        @factory.add_attribute(:test, 'original')
+        Factory.alias(/(.*)_alias/, '\1')
+        @result = @factory.attributes_for(:test_alias => 'new')
+      end
+
+      should "use the passed in value for the alias" do
+        assert_equal 'new', @result[:test_alias]
+      end
+
+      should "discard the predefined value for the attribute" do
+        assert_nil @result[:test]
+      end
+
+    end
+
     should "guess the build class from the factory name" do
       assert_equal User, @factory.build_class
     end
@@ -427,29 +415,20 @@ class FactoryTest < Test::Unit::TestCase
 
   end
 
-  context "after defining a sequence" do
-
-    setup do
-      @sequence = mock('sequence')
-      @name     = :test
-      @value    = '1 2 5'
-
-      @sequence.        stubs(:next).returns(@value)
-      Factory::Sequence.stubs(:new). returns(@sequence)
-
-      Factory.sequence(@name) {}
-    end
-
-    should "call next on the sequence when sent next" do
-      @sequence.expects(:next)
-
-      Factory.next(@name)
-    end
-
-    should "return the value from the sequence" do
-      assert_equal @value, Factory.next(@name)
+  Factory.definition_file_paths.each do |file|
+    should "automatically load definitions from #{file}.rb" do
+      Factory.stubs(:require).raises(LoadError)
+      Factory.expects(:require).with(file)
+      Factory.find_definitions
     end
+  end
 
+  should "only load the first set of factories detected" do
+    first, second, third = Factory.definition_file_paths
+    Factory.expects(:require).with(first).raises(LoadError)
+    Factory.expects(:require).with(second)
+    Factory.expects(:require).with(third).never
+    Factory.find_definitions
   end
 
 end

data/test/integration_test.rb

@@ -74,6 +74,10 @@ class IntegrationTest < Test::Unit::TestCase
       assert @instance.author.new_record?
     end
 
+    should "not assign both an association and its foreign key" do
+      assert_equal 1, Factory.build(:post, :author_id => 1).author_id
+    end
+
   end
 
   context "a created instance" do

data/test/sequence_test.rb

@@ -26,4 +26,51 @@ class SequenceTest < Test::Unit::TestCase
 
   end
 
+  context "defining a sequence" do
+
+    setup do
+      @sequence = mock('sequence')
+      @name     = :count
+      Factory::Sequence.stubs(:new).returns(@sequence)
+    end
+
+    should "create a new sequence" do
+      Factory::Sequence.expects(:new).with().returns(@sequence)
+      Factory.sequence(@name)
+    end
+
+    should "use the supplied block as the sequence generator" do
+      Factory::Sequence.stubs(:new).yields(1)
+      yielded = false
+      Factory.sequence(@name) {|n| yielded = true }
+      assert yielded
+    end
+
+  end
+
+  context "after defining a sequence" do
+
+    setup do
+      @sequence = mock('sequence')
+      @name     = :test
+      @value    = '1 2 5'
+
+      @sequence.        stubs(:next).returns(@value)
+      Factory::Sequence.stubs(:new). returns(@sequence)
+
+      Factory.sequence(@name) {}
+    end
+
+    should "call next on the sequence when sent next" do
+      @sequence.expects(:next)
+
+      Factory.next(@name)
+    end
+
+    should "return the value from the sequence" do
+      assert_equal @value, Factory.next(@name)
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: factory_girl
 version: !ruby/object:Gem::Version 
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors: 
 - Joe Ferris
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-30 00:00:00 -04:00
+date: 2008-09-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,11 +35,15 @@ files:
 - LICENSE
 - Rakefile
 - README.textile
+- lib/factory_girl/aliases.rb
+- lib/factory_girl/attribute.rb
 - lib/factory_girl/attribute_proxy.rb
 - lib/factory_girl/factory.rb
 - lib/factory_girl/sequence.rb
 - lib/factory_girl.rb
+- test/aliases_test.rb
 - test/attribute_proxy_test.rb
+- test/attribute_test.rb
 - test/factory_test.rb
 - test/integration_test.rb
 - test/models.rb
@@ -77,7 +81,9 @@ signing_key:
 specification_version: 2
 summary: factory_girl provides a framework and DSL for defining and using model instance factories.
 test_files: 
+- test/aliases_test.rb
 - test/attribute_proxy_test.rb
+- test/attribute_test.rb
 - test/factory_test.rb
 - test/integration_test.rb
 - test/sequence_test.rb