factory_girl 1.1.5 → 1.2.0

data/lib/factory_girl/proxy.rb

@@ -0,0 +1,62 @@
+class Factory
+
+  class Proxy #:nodoc:
+    def initialize(klass)
+    end
+
+    def get(attribute)
+      nil
+    end
+
+    def set(attribute, value)
+    end
+
+    def associate(name, factory, attributes)
+    end
+
+    # Generates an association using the current build strategy.
+    #
+    # Arguments:
+    #   name: (Symbol)
+    #     The name of the factory that should be used to generate this
+    #     association.
+    #   attributes: (Hash)
+    #     A hash of attributes that should be overridden for this association.
+    #
+    # Returns:
+    #   The generated association for the current build strategy. Note that
+    #   assocaitions are not generated for the attributes_for strategy. Returns
+    #   nil in this case.
+    #
+    # Example:
+    #
+    #   Factory.define :user do |f|
+    #     # ...
+    #   end
+    #
+    #   Factory.define :post do |f|
+    #     # ...
+    #     f.author {|a| a.association :user, :name => 'Joe' }
+    #   end
+    #
+    #   # Builds (but doesn't save) a Post and a User
+    #   Factory.build(:post)
+    #
+    #   # Builds and saves a User, builds a Post, assigns the User to the 
+    #   # author association, and saves the User.
+    #   Factory.create(:post)
+    #
+    def association(name, overrides = {})
+      nil
+    end
+
+    def method_missing(method, *args, &block)
+      get(method)
+    end
+
+    def result
+      raise NotImplementedError, "Strategies must return a result"
+    end
+  end
+
+end

data/lib/factory_girl/proxy/attributes_for.rb

@@ -0,0 +1,21 @@
+class Factory
+  class Proxy #:nodoc:
+    class AttributesFor < Proxy #:nodoc:
+      def initialize(klass)
+        @hash = {}
+      end
+
+      def get(attribute)
+        @hash[attribute]
+      end
+
+      def set(attribute, value)
+        @hash[attribute] = value
+      end
+
+      def result
+        @hash
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/build.rb

@@ -0,0 +1,29 @@
+class Factory
+  class Proxy #:nodoc:
+    class Build < Proxy #:nodoc:
+      def initialize(klass)
+        @instance = klass.new
+      end
+
+      def get(attribute)
+        @instance.send(attribute)
+      end
+
+      def set(attribute, value)
+        @instance.send(:"#{attribute}=", value)
+      end
+
+      def associate(name, factory, attributes)
+        set(name, Factory.create(factory, attributes))
+      end
+
+      def association(factory, overrides = {})
+        Factory.create(factory, overrides)
+      end
+
+      def result
+        @instance
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/create.rb

@@ -0,0 +1,10 @@
+class Factory
+  class Proxy #:nodoc:
+    class Create < Build #:nodoc:
+      def result
+        @instance.save!
+        @instance
+      end
+    end
+  end
+end

data/lib/factory_girl/proxy/stub.rb

@@ -0,0 +1,28 @@
+class Factory 
+  class Proxy
+    class Stub < Proxy #:nodoc:
+      def initialize(klass)
+        @mock = Object.new
+      end
+      
+      def get(attribute)
+        @mock.send(attribute)
+      end
+      
+      def set(attribute, value)
+        unless @mock.respond_to?("attribute=")
+          class << @mock; self end.send(:attr_accessor, attribute)
+        end
+        @mock.send("#{attribute}=", value)
+      end
+      
+      def associate(name, factory, attributes)
+        set(name, nil)
+      end
+      
+      def result
+        @mock      
+      end
+    end
+  end
+end

data/lib/factory_girl/sequence.rb

@@ -1,5 +1,7 @@
 class Factory
 
+  # Sequences are defined using Factory.sequence. Sequence values are generated
+  # using next.
   class Sequence
 
     def initialize (&proc) #:nodoc:

data/lib/factory_girl/syntax.rb

@@ -0,0 +1,12 @@
+class Factory
+  # Provides alternate syntaxes for factory_girl. If you don't like the default
+  # syntax for defining or using factories, look at one of the Factory::Syntax
+  # modules:
+  #
+  # * Factory::Syntax::Blueprint: definition syntax similar to Machinist
+  # * Factory::Syntax::Generate: usage syntax similar to Object Daddy
+  # * Factory::Syntax::Make: usage syntax similar to Machinist
+  # * Factory::Syntax::Sham: sequence syntax similar to Machinist
+  module Syntax
+  end
+end

data/lib/factory_girl/syntax/blueprint.rb

@@ -0,0 +1,42 @@
+class Factory
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is an
+    # alternate syntax for defining factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/blueprint'
+    #
+    #   User.blueprint do
+    #     name  { 'Billy Bob'             }
+    #     email { 'billy@bob.example.com' }
+    #   end
+    #
+    #   Factory(:user, :name => 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Blueprint
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def blueprint(&block)
+            instance = Factory.new(name.underscore, :class => self)
+            instance.instance_eval(&block)
+            Factory.factories[instance.factory_name] = instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Factory::Syntax::Blueprint::ActiveRecord)
+

data/lib/factory_girl/syntax/generate.rb

@@ -0,0 +1,68 @@
+class Factory
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide generation methods for factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/generate'
+    #
+    #   Factory.define :user do |factory|
+    #     factory.name 'Billy Bob'
+    #     factory.email 'billy@bob.example.com'
+    #   end
+    #
+    #   # Creates a saved instance without raising (same as saving the result
+    #   # of Factory.build)
+    #   User.generate(:name => 'Johnny')
+    #
+    #   # Creates a saved instance and raises when invalid (same as
+    #   # Factory.create)
+    #   User.generate!
+    #
+    #   # Creates an unsaved instance (same as Factory.build)
+    #   User.spawn
+    #
+    #   # Creates an instance and yields it to the passed block
+    #   User.generate do |user|
+    #     # ...do something with user...
+    #   end
+    #
+    # This syntax was derived from Rick Bradley and Yossef Mendelssohn's
+    # object_daddy.
+    module Generate
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def generate(overrides = {}, &block)
+            instance = Factory.build(name.underscore, overrides)
+            instance.save
+            yield(instance) if block_given?
+            instance
+          end
+
+          def generate!(overrides = {}, &block)
+            instance = Factory.create(name.underscore, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+          def spawn(overrides = {}, &block)
+            instance = Factory.build(name.underscore, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Factory::Syntax::Generate::ActiveRecord)

data/lib/factory_girl/syntax/make.rb

@@ -0,0 +1,39 @@
+class Factory
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is a
+    # shortcut for Factory.create.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/make'
+    #   
+    #   Factory.define :user do |factory|
+    #     factory.name 'Billy Bob'
+    #     factory.email 'billy@bob.example.com'
+    #   end
+    #
+    #   User.make(:name => 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Make
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def make(overrides = {})
+            Factory.create(name.underscore, overrides)
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Factory::Syntax::Make::ActiveRecord)

data/lib/factory_girl/syntax/sham.rb

@@ -0,0 +1,42 @@
+class Factory
+  module Syntax
+
+    # Adds a Sham module, which provides an alternate interface to
+    # Factory::Sequence.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/sham'
+    #
+    #   Sham.email {|n| "somebody#{n}@example.com" }
+    #
+    #   Factory.define :user do |factory|
+    #     factory.email { Sham.email }
+    #   end
+    #
+    # Note that you can also use Faker, but it is recommended that you simply
+    # use a sequence as in the above example, as factory_girl does not provide
+    # protection against duplication in randomized sequences, and a randomized
+    # value does not provide any tangible benefits over an ascending sequence.
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Sham
+      module Sham #:nodoc:
+        def self.method_missing(name, &block)
+          if block_given?
+            Factory.sequence(name, &block)
+          else
+            Factory.next(name)
+          end
+        end
+
+        # overrides name on Module
+        def self.name(&block)
+          method_missing('name', &block)
+        end
+      end
+    end
+  end
+end
+
+include Factory::Syntax::Sham

data/test/aliases_test.rb

@@ -1,4 +1,4 @@
-require(File.join(File.dirname(__FILE__), 'test_helper'))
+require 'test_helper'
 
 class AliasesTest < Test::Unit::TestCase
 

data/test/association_attribute_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class AssociationAttributeTest < Test::Unit::TestCase
+
+  context "an association" do
+    setup do
+      @name      = :author
+      @factory   = :user
+      @overrides = { :first_name => 'John' }
+      @attr      = Factory::Attribute::Association.new(@name,
+                                                       @factory,
+                                                       @overrides)
+    end
+
+    should "have a name" do
+      assert_equal @name, @attr.name
+    end
+
+    should "tell the proxy to associate when being added to a proxy" do
+      proxy = mock('proxy')
+      proxy.expects(:associate).with(@name, @factory, @overrides)
+      @attr.add_to(proxy)
+    end
+  end
+
+  should "convert names to symbols" do
+    assert_equal :name, 
+                 Factory::Attribute::Association.new('name', :user, {}).name
+  end
+
+end

data/test/attribute_test.rb

@@ -1,70 +1,32 @@
-require(File.join(File.dirname(__FILE__), 'test_helper'))
+require '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)
+      @attr  = Factory::Attribute.new(@name)
     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)
+    should "do nothing when being added to a proxy" do
+      @proxy = mock('proxy')
+      @proxy.expects(:set).never
+      @attr.add_to(@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 {})
+      Factory::Attribute.new('test=')
     end
   end
 
   should "convert names to symbols" do
-    assert_equal :name, Factory::Attribute.new('name', nil, nil).name
+    assert_equal :name, Factory::Attribute.new('name').name
   end
 
 end