modelfactory 0.8.1 → 0.8.9

data/History.txt

@@ -1,15 +1,15 @@
-== 0.8.1 2009-05-08
+== 0.8.9 2009-05-19
+* Renamed the required lib to 'modelfactory'
+* Completely redesigned API, see the documentation in README.txt
 
+== 0.8.1 2009-05-08
 * Ruby 1.9.1 compatibility
 
 == 0.8.0 2008-12-10
-
 * added the ability to specify multiple named types of defaults
 
 == 0.7.0 2008-11-11
-
 * Documentation and rubygem
 
 == 0.0.1 2008-01-25
-
 * Initial release

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Zack Hobson and Justin Balthrop, Geni.com
+Copyright (c) 2008, 2009 Zack Hobson and Justin Balthrop
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Manifest.txt

@@ -5,11 +5,18 @@ README.txt
 Rakefile
 lib/fixture_converter.rb
 lib/model_factory.rb
-lib/model_factory/version.rb
+lib/modelfactory.rb
+lib/modelfactory/factory.rb
+lib/modelfactory/legacy.rb
+lib/modelfactory/version.rb
 script/destroy
 script/fixtures2factories
 script/generate
 script/txt2html
 setup.rb
+test/fixtures/schema.rb
+test/fixtures/strict_widget.rb
+test/fixtures/widget.rb
+test/model_factory_legacy_test.rb
 test/model_factory_test.rb
 test/test_helper.rb

data/README.txt

@@ -6,117 +6,76 @@ Rails applications.
 The best explanation for the motivation behind ModelFactory (and the inspiration
 for this module) comes from Dan Manges' blog: http://www.dcmanges.com/blog/38
 
-The idea is that instead of keeping your test data in a nearly opaque fixture
-file, you generate data in the test itself using a custom factory API designed
-for your test environment.
+NOTE that the API has changed recently, but ModelFactory is still fully
+backward-compatible with previous releases. For a description of the original
+API see ModelFactory::Legacy.
 
-By creating a new module just for your test factory API you make it easier
-to spot factory calls in your tests and keep your factory code out of your
-test code. ModelFactory adds some useful facilities for generating optional
-defaults for commonly instantiated types. It also fakes up id generation in
-the ActiveRecord models created with new, to assist in unit testing without
-the database.
+== Usage
 
-=== A Note About Defaults
-
-The purpose of default values is to generate valid instances, not to serve as
-replacements for fixture data. When writing tests that use factory-generated
-objects, it's important never to depend on default values in your test assertions.
-If you depend on defaults in your tests they become more fragile and the intention
-is harder to discern. Alway override values you care about when using factory objects.
+The essential purpose of ModelFactory is the automatic generation of valid,
+opaque ActiveRecord objects whose contents are unimportant.
 
-If you find yourself repeating the same initialization to avoid using defaults,
-consider whether it would be appropriate to add a custom toplevel method to
-your factory module that includes this initialization. You can also specify
-multiple named types of defaults, described below. Be aware that both of these
-techniques should be used sparingly, as they can have some of the same issues
-as fixtures.
+ require 'modelfactory'
 
-=== A Note About ID Generation
-
-Since basic ID generation is done when you instantiate objects using
-Factory.new_<type> it is recommended not to mix such objects with those
-created using Factory.create_<type>. Use the former in unit tests and
-use the latter in functional tests.
-
-== Using ModelFactory
-
-Put something like this in your test helper:
+ ModelFactory.configuration do
+   default(User) do |m|
+     m.name = "Factory User"
+     m.email = "user@factory.ws"
+   end
+ end
 
- require 'model_factory'
+ ModelFactory[User].create.name  # => 'Factory User'
 
- module Factory
-   extend ModelFactory
+If you don't care for the factory creation syntax, ModelFactory defines the
+factory class method on ActiveRecord models. The following is equivalent
+to ModelFactory[User].create:
 
-   # a default block accepts a class and a hash of default values
-   default Color, {
-     :name => 'chartreuse'
-   }
+ User.factory.create
 
-   default User, {
-     :first_name => 'Harry',
-     :last_name => 'Manchester',
-     :favorite_color => default_color
-   }
+Since factory-created instances are meant to be valid, you will probably
+need a way to generate unique values. ModelFactory keeps a counter for each
+type that increments when each new instance is created. This counter is passed
+to configuration blocks to make it easier to generate unique values:
 
-   # Add class methods to create whatever kind of objects you need for your tests
-   def self.new_user_with_colorblindness
-     new_user { :favorite_color => nil }
+ ModelFactory.configuration do
+   default(User) do |m, i|
+     m.name = "Factory User #{i}"
+     m.email = "user#{i}@factory.ws"
    end
-
  end
 
-Then in your tests you use Factory methods to instantiate your test objects:
+ User.factory.create.name  # => 'Factory User 1'
+ User.factory.create.email # => 'user2@factory.ws'
 
- # For most functional tests you can use create.
- def test_something
-   user = Factory.create_user
-   user.friends << Factory.create_user(:first_name => 'Frank')
-   assert user.likes_frank?
- end
+Defaults can be overriden on instance creation. By not specifying unimportant
+values, the intention of your tests becomes clearer:
 
- # For unit tests you use new.
- def test_something_else
-   user = Factory.new_user(:favorite_color => Factory.new_color(:name => 'blue'))
-   assert user.likes_blue?
+ def test_welcome
+    user = ModelFactory[User].create(:name => 'bob')
+    assert_equal 'Welcome, bob!', user.welcome
  end
 
- # Assertions should not depend on default data, but it can be useful to create
- # factory methods that build objects with specific traits.
- def test_yet_something_else
-   user = Factory.new_user_with_colorblindness
-   assert !user.likes_blue?
- end
+It's possible to configure named factories:
 
-You can also specify types of models in your calls to defaults, but be careful. This can
-easily start to become a lot like fixtures:
-
- module Factory
-   extend ModelFactory
-
-   default User, :joined {
-     :first_name => 'Harry',
-     :last_name => 'Manchester',
-     :joined => true,
-     :set_password => true,
-   }
-  
-   default User, :unjoined {
-     :first_name => 'Harry',
-     :last_name => 'Manchester',
-     :joined => false,
-     :set_password => false,
-   }
+ ModelFactory.configuration do
+   admin(User) do |m, i|
+     m.name = "Admin User #{i}"
+     m.admin = true
+   end
  end
 
-Then in your test:
+ User.factory.create_admin.admin  # => true
 
- def test_something
-   user1 = Factory.create_joined_user(:first_name => 'Bill')
-   user2 = Factory.create_unjoined_user(:first_name => 'Sandy')
-   assert  user1.joined?
-   assert !user2.joined?
- end
+Named factories do not inherit anything from the default, so you'll still need to
+provide enough to data to allow the creation of valid objects.
+
+=== A Note About Defaults
+
+The purpose of default values is to generate valid instances, not to serve as
+replacements for fixture data. When writing tests that use factory-generated
+objects, it's important never to depend on default values in your test assertions.
+If you depend on defaults in your tests they become more fragile and the intention
+is harder to discern. Alway override values you care about when using factory objects.
 
 == Installing ModelFactory
 
@@ -124,6 +83,7 @@ Then in your test:
 
 == License
 
-Copyright (c) 2008 Justin Balthrop and Zack Hobson
+Copyright (c) 2008, 2009 Justin Balthrop and Zack Hobson
+
 Published under The MIT License, see License.txt
 

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'hoe'
 $:.unshift(File.dirname(__FILE__) + "/lib")
-require 'model_factory/version'
+require 'modelfactory/version'
 
 Hoe.new('ModelFactory', ModelFactory::VERSION::STRING) do |p|
   p.name = "modelfactory"
@@ -15,6 +15,7 @@ Hoe.new('ModelFactory', ModelFactory::VERSION::STRING) do |p|
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   p.test_globs = ["test/**/*_test.rb"]
   p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+  p.extra_dev_deps = ['active_record', 'mocha', 'thoughtbot-shoulda', 'sqlite3-ruby']
 end
 
 

data/lib/fixture_converter.rb

@@ -1,4 +1,4 @@
-class FixtureConverter
+class FixtureConverter # :nodoc:
   def initialize(opts = {})
     @body   = []
     @header = []
@@ -94,4 +94,4 @@ private
     end
     ws + line
   end
-end
+end

data/lib/model_factory.rb

@@ -1,113 +1,13 @@
+#
+# This is the legacy modelfactory API.
+# The current implementation is in lib/modelfactory.rb.
+#
 require 'rubygems'
 require 'active_record'
+require 'modelfactory/legacy'
 
 module ModelFactory
-  def next_local_id # :nodoc:
-    @max_id ||= 0
-    return @max_id += 1
-  end
-
-  #
-  # When specifying defaults, you should only provide only enough data that
-  # the created instance is valid. If you want to include another factory
-  # object as a dependency use the special method default_* instead of
-  # create_* or new_*.
-  #
-  def default(class_type, *default_args)
-    defaults   = default_args.pop || {}
-    prefix     = default_args.first
-    class_name = class_type.name.demodulize.underscore
-    class_name = "#{prefix}_#{class_name}" if prefix
-
-    (class << self; self; end).module_eval do
-      define_method "create_#{class_name}" do |*args|
-        attributes = args.first || {}
-        create_instance(class_type, attributes, defaults)
-      end
-    
-      define_method "new_#{class_name}" do |*args|
-        attributes = args.first || {}
-        new_instance(class_type, attributes, defaults)
-      end
-
-      define_method "default_#{class_name}" do |*args|
-        attributes = args.first || {}
-        default_closure(class_type, attributes, defaults)
-      end
-    end
-  end
-    
-  def create_instance(class_type, attributes, defaults = {}) # :nodoc:
-    attributes = instantiate_defaults(:create, defaults.merge(attributes))
-    instance = class_type.create!(attributes)
-    if update_protected_attributes(instance, attributes)
-      instance.save
-    end
-    instance
-  end
-  
-  def new_instance(class_type, attributes, defaults = {}) # :nodoc:
-    attributes = instantiate_defaults(:new, defaults.merge(attributes))
-    instance = class_type.new(attributes)
-    instance.id = next_local_id
-    update_protected_attributes(instance, attributes)
-    instance
-  end
-
-  def default_closure(class_type, attributes, defaults = {}) # :nodoc:
-    lambda do |create_or_new|
-      case create_or_new
-      when :new    ; new_instance(class_type, attributes, defaults)
-      when :create ; create_instance(class_type, attributes, defaults)
-      end
-    end
-  end
-  
-  def instantiate_defaults(create_or_new, attributes) # :nodoc:
-    attributes.each do |key, value|
-      if value.is_a?(Proc)
-        attributes[key] = value.arity == 0 ? value.call : value.call(create_or_new)
-      end
-    end
-    attributes
-  end
-
-  def update_protected_attributes(instance, attributes) # :nodoc:
-    modified = false
-    protected_attrs  = instance.class.protected_attributes
-    protected_attrs  = protected_attrs.to_set if protected_attrs
-    accessible_attrs = instance.class.accessible_attributes
-    accessible_attrs = accessible_attrs.to_set if accessible_attrs
-
-    if protected_attrs or accessible_attrs
-      attributes.each do |key, value|
-        # Support symbols and strings.
-        next if protected_attrs  and (not protected_attrs.include?(key) or protected_attrs.include?(key.to_s))
-        next if accessible_attrs and (accessible_attrs.include?(key) or accessible_attrs.include?(key.to_s))
-        modified = true
-        instance.send("#{key}=", value)
-      end
-    end
-    return modified
-  end
-
-  # Any class methods of the form "new_some_type(attrs)" or "create_some_type(attrs)" will be converted to
-  # "SomeType.new(attrs)" and "SomeType.create!(attrs)" respectively.
-  # These basically function as though you'd used the 'default' directive with empty defaults.
-  def method_missing(missing_method, attributes = {})
-    if missing_method.to_s.match(/^(new|create|default)_([a-z][\w_]+)$/)
-      method, class_name = $1, $2
-      class_type = class_name.camelize.constantize
-      case method
-      when 'create'
-        create_instance(class_type, attributes)
-      when 'new'
-        new_instance(class_type, attributes)
-      when 'default'
-        default_closure(class_type, attributes)
-      end
-    else
-      raise NoMethodError, "no such method '#{missing_method}'"
-    end
+  def self.extended(mod)
+    mod.extend(ModelFactory::Legacy)
   end
 end

data/lib/modelfactory.rb

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'active_record'
+require 'modelfactory/factory'
+require 'modelfactory/legacy'
+
+ActiveRecord::Base.class_eval do
+  def self.factory ; ModelFactory[self] ; end
+end
+
+module ModelFactory
+  # Configure the factory singleton by passing a block.
+  #
+  # You can call this method multiple times. Each time you do so it will
+  # clear the existing configuration and reset the counters.
+  #
+  # You don't need to configure ModelFactory to use it.
+  def self.configure(&block)
+    @singleton = Wrapper.new(&block)
+  end
+
+  # Get the Factory for a given model class.
+  def self.[](klass)
+    @singleton ||= Wrapper.new
+    @singleton.wrap(klass)
+  end
+
+  # Enable legacy API compatibility.
+  def self.extended(mod) # :nodoc:
+    mod.extend(ModelFactory::Legacy)
+  end
+
+  # Singleton Factory wrapper class.
+  class Wrapper # :nodoc:
+    # Create a new FactoryConfiguration with the given block.
+    def initialize(&block)
+      @config = FactoryConfiguration.new(&block)
+      @factory = {}
+    end
+
+    # Wraps a given class in a configured Factory instance.
+    def wrap(klass)
+      @factory[klass] ||= Factory.new(klass, @config.class_opts[klass])
+    end
+  end
+
+  # Factory configuration class.
+  class FactoryConfiguration # :nodoc:
+    attr_reader :class_opts
+
+    def initialize(&block)
+      @class_opts = {}
+      instance_eval(&block) if block_given?
+    end
+
+    # All method calls set up a configuration named after the method.
+    def method_missing(method, klass, &block)
+      @class_opts[klass] ||= {}
+      @class_opts[klass][method] = block
+    end
+  end
+end

data/lib/modelfactory/factory.rb

@@ -0,0 +1,59 @@
+module ModelFactory # :nodoc:
+  # This API allows you to instantiate models.
+  class Factory # :nodoc:
+    def initialize(klass, opt)
+      @counter = 0
+      @class = klass
+      @options = opt || {}
+    end
+
+    def create(opt = {}, &block)
+      create_named(:default, opt, &block)
+    end
+
+    def new(opt = {}, &block)
+      new_named(:default, opt, &block)
+    end
+
+    def method_missing(method, opt = {}, &block)
+      case method.to_s
+      when /^create_(.+)$/
+        create_named($1.to_sym, opt, &block)
+      when /^new_(.+)$/
+        new_named($1.to_sym, opt, &block)
+      else
+        raise NameError, "no such method `#{method}'"
+      end
+    end
+
+   private
+
+    def next_counter
+      @counter += 1
+    end
+
+    def new_named(name, opt = {}, &block)
+      instance = @class.new
+      if @options[name]
+        case @options[name].arity
+        when 2
+          @options[name].call(instance, next_counter) if @options[name]
+        else
+          @options[name].call(instance) if @options[name]
+        end
+      end
+      opt.each {|k,v| instance.send("#{k}=", v) }
+      yield instance if block_given?
+      instance
+    end
+
+    def create_named(name, opt = {}, &block)
+      instance = new_named(name, opt, &block)
+      instance.save!
+      instance.reload
+      instance
+    end
+
+  end
+
+end

data/lib/modelfactory/legacy.rb

@@ -0,0 +1,191 @@
+module ModelFactory
+  # == ModelFactory Legacy API
+  # 
+  # Put something like this in your test helper:
+  # 
+  #  require 'model_factory'
+  # 
+  #  module Factory
+  #    extend ModelFactory
+  # 
+  #    # a default block accepts a class and a hash of default values
+  #    default Color, {
+  #      :name => 'chartreuse'
+  #    }
+  # 
+  #    default User, {
+  #      :first_name => 'Harry',
+  #      :last_name => 'Manchester',
+  #      :favorite_color => default_color
+  #    }
+  # 
+  #    # Add class methods to create whatever kind of objects you need for your tests
+  #    def self.new_user_with_colorblindness
+  #      new_user { :favorite_color => nil }
+  #    end
+  # 
+  #  end
+  # 
+  # Then in your tests you use Factory methods to instantiate your test objects:
+  # 
+  #  # For most functional tests you can use create.
+  #  def test_something
+  #    user = Factory.create_user
+  #    user.friends << Factory.create_user(:first_name => 'Frank')
+  #    assert user.likes_frank?
+  #  end
+  # 
+  #  # For unit tests you use new.
+  #  def test_something_else
+  #    user = Factory.new_user(:favorite_color => Factory.new_color(:name => 'blue'))
+  #    assert user.likes_blue?
+  #  end
+  # 
+  #  # Assertions should not depend on default data, but it can be useful to create
+  #  # factory methods that build objects with specific traits.
+  #  def test_yet_something_else
+  #    user = Factory.new_user_with_colorblindness
+  #    assert !user.likes_blue?
+  #  end
+  # 
+  # You can also specify types of models in your calls to defaults, but be careful. This can
+  # easily start to become a lot like fixtures:
+  # 
+  #  module Factory
+  #    extend ModelFactory
+  # 
+  #    default User, :joined {
+  #      :first_name => 'Harry',
+  #      :last_name => 'Manchester',
+  #      :joined => true,
+  #      :set_password => true,
+  #    }
+  #   
+  #    default User, :unjoined {
+  #      :first_name => 'Harry',
+  #      :last_name => 'Manchester',
+  #      :joined => false,
+  #      :set_password => false,
+  #    }
+  #  end
+  # 
+  # Then in your test:
+  # 
+  #  def test_something
+  #    user1 = Factory.create_joined_user(:first_name => 'Bill')
+  #    user2 = Factory.create_unjoined_user(:first_name => 'Sandy')
+  #    assert  user1.joined?
+  #    assert !user2.joined?
+  #  end
+  # 
+  module Legacy
+    def next_local_id # :nodoc:
+      @max_id ||= 0
+      return @max_id += 1
+    end
+
+    #
+    # When specifying defaults, you should only provide only enough data that
+    # the created instance is valid. If you want to include another factory
+    # object as a dependency use the special method default_* instead of
+    # create_* or new_*.
+    #
+    def default(class_type, *default_args)
+      defaults   = default_args.pop || {}
+      prefix     = default_args.first
+      class_name = class_type.name.demodulize.underscore
+      class_name = "#{prefix}_#{class_name}" if prefix
+
+      (class << self; self; end).module_eval do
+        define_method "create_#{class_name}" do |*args|
+          attributes = args.first || {}
+          create_instance(class_type, attributes, defaults)
+        end
+      
+        define_method "new_#{class_name}" do |*args|
+          attributes = args.first || {}
+          new_instance(class_type, attributes, defaults)
+        end
+
+        define_method "default_#{class_name}" do |*args|
+          attributes = args.first || {}
+          default_closure(class_type, attributes, defaults)
+        end
+      end
+    end
+      
+    def create_instance(class_type, attributes, defaults = {}) # :nodoc:
+      attributes = instantiate_defaults(:create, defaults.merge(attributes))
+      instance = class_type.create!(attributes)
+      if update_protected_attributes(instance, attributes)
+        instance.save
+      end
+      instance
+    end
+    
+    def new_instance(class_type, attributes, defaults = {}) # :nodoc:
+      attributes = instantiate_defaults(:new, defaults.merge(attributes))
+      instance = class_type.new(attributes)
+      instance.id = next_local_id
+      update_protected_attributes(instance, attributes)
+      instance
+    end
+
+    def default_closure(class_type, attributes, defaults = {}) # :nodoc:
+      lambda do |create_or_new|
+        case create_or_new
+        when :new    ; new_instance(class_type, attributes, defaults)
+        when :create ; create_instance(class_type, attributes, defaults)
+        end
+      end
+    end
+    
+    def instantiate_defaults(create_or_new, attributes) # :nodoc:
+      attributes.each do |key, value|
+        if value.is_a?(Proc)
+          attributes[key] = value.arity == 0 ? value.call : value.call(create_or_new)
+        end
+      end
+      attributes
+    end
+
+    def update_protected_attributes(instance, attributes) # :nodoc:
+      modified = false
+      protected_attrs  = instance.class.protected_attributes
+      protected_attrs  = protected_attrs.to_set if protected_attrs
+      accessible_attrs = instance.class.accessible_attributes
+      accessible_attrs = accessible_attrs.to_set if accessible_attrs
+
+      if protected_attrs or accessible_attrs
+        attributes.each do |key, value|
+          # Support symbols and strings.
+          next if protected_attrs  and (not protected_attrs.include?(key) or protected_attrs.include?(key.to_s))
+          next if accessible_attrs and (accessible_attrs.include?(key) or accessible_attrs.include?(key.to_s))
+          modified = true
+          instance.send("#{key}=", value)
+        end
+      end
+      return modified
+    end
+
+    # Any class methods of the form "new_some_type(attrs)" or "create_some_type(attrs)" will be converted to
+    # "SomeType.new(attrs)" and "SomeType.create!(attrs)" respectively.
+    # These basically function as though you'd used the 'default' directive with empty defaults.
+    def method_missing(missing_method, attributes = {})
+      if missing_method.to_s.match(/^(new|create|default)_([a-z][\w_]+)$/)
+        method, class_name = $1, $2
+        class_type = class_name.camelize.constantize
+        case method
+        when 'create'
+          create_instance(class_type, attributes)
+        when 'new'
+          new_instance(class_type, attributes)
+        when 'default'
+          default_closure(class_type, attributes)
+        end
+      else
+        raise NoMethodError, "no such method '#{missing_method}'"
+      end
+    end
+  end
+end

data/lib/{model_factory → modelfactory}/version.rb

@@ -2,7 +2,7 @@ module ModelFactory #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 8
-    TINY  = 1
+    TINY  = 9
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/fixtures/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define do
+  create_table "widgets", :force => true do |t|
+    t.string   "name"
+    t.decimal  "price"
+    t.string   "type"
+  end
+end
+

data/test/fixtures/strict_widget.rb

@@ -0,0 +1,6 @@
+
+class StrictWidget < Widget
+  validates_presence_of     :name
+  validates_numericality_of :price
+end
+

data/test/fixtures/widget.rb

@@ -0,0 +1,4 @@
+
+class Widget < ActiveRecord::Base
+end
+

data/test/model_factory_legacy_test.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/test_helper'
+require File.dirname(__FILE__) + '/../lib/model_factory'
+
+# The classes below are rough mocks of ActiveRecord::Base that only handle instantiation.
+
+# This class has defaults defined.
+class ModelFactoryTestDef
+  def self.protected_attributes;  nil; end
+  def self.accessible_attributes; nil; end
+  
+  attr_accessor :id, :nest, :bar, :baz
+  def initialize(opts = {})
+    opts.each do |k,v|
+      self.send("#{k}=", v)
+    end
+  end
+end
+
+# This class has no defaults defined.
+class ModelFactoryTestNoDef < ModelFactoryTestDef; end
+
+# This class has nested defaults defined.
+class ModelFactoryTestNestDef < ModelFactoryTestDef; end
+
+# This class has protected attributes.
+class ModelFactoryTestProtected < ModelFactoryTestDef
+  def self.protected_attributes; [:baz]; end
+
+  def initialize(opts = {})
+    opts = opts.clone
+    opts.delete(:baz) # Simulate a protected attribute.
+    super(opts)
+  end
+end
+
+# This class has accessible attributes.
+class ModelFactoryTestAccessible < ModelFactoryTestDef
+  def self.accessible_attributes; [:id, :nest, 'bar']; end
+
+  def initialize(opts = {})
+    opts = opts.clone
+    opts.delete(:baz) # Simulate a protected attribute.
+    super(opts)
+  end
+end
+
+# This is the testfactory class def with test defaults.
+class ModelFactoryTestFactory
+  extend ModelFactory
+  default ModelFactoryTestDef, { :bar => 'baz' }
+  default ModelFactoryTestNestDef, { :nest => default_model_factory_test_def }
+end
+
+class ModelFactoryTest < Test::Unit::TestCase
+  context "legacy api compatibility" do
+    should "initialize protected attributes" do
+      m = ModelFactoryTestFactory.new_model_factory_test_protected(:baz => 4)
+      assert_equal 4, m.baz
+    end
+    
+    should "initialize dynamic protected attributes" do
+      i = 1
+      m = ModelFactoryTestFactory.new_model_factory_test_protected(:bar => 3, :baz => lambda { i += 1 } )
+      assert_equal 2, m.baz
+    end
+  
+    should "initialize accessible attributes" do
+      m = ModelFactoryTestFactory.new_model_factory_test_accessible(:baz => 4)
+      assert_equal 4, m.baz
+    end
+    
+    should "initialize dynamic accessible attributes" do
+      i = 1
+      m = ModelFactoryTestFactory.new_model_factory_test_accessible(:bar => 3, :baz => lambda { i += 1 } )
+      assert_equal 2, m.baz
+    end
+  
+    should "initialize with no arguments and nested defaults" do
+      m = ModelFactoryTestFactory.new_model_factory_test_nest_def
+      assert m.nest.id > 0
+      assert m.id > 0
+    end
+  
+    should "intialize with arguments and nested defaults" do
+      m = ModelFactoryTestFactory.new_model_factory_test_nest_def(:bar => 'foo')
+      assert_equal 'foo', m.bar
+      assert m.nest.id > 0
+      assert m.id > 0
+    end
+  
+    should "intialize with no arguments and explicit defaults" do
+      m = ModelFactoryTestFactory.new_model_factory_test_def
+      assert_equal 'baz', m.bar
+      assert m.id > 0
+    end
+  
+    should "intialize with arguments and explicit defaults" do
+      m = ModelFactoryTestFactory.new_model_factory_test_def(:bar => 'foo')
+      assert_equal 'foo', m.bar
+      assert m.id > 0
+    end
+  
+    should "create with arguments and explicit defaults" do
+      instance = ModelFactoryTestDef.new
+      ModelFactoryTestDef.expects(:create!).with(:bar => 'foo').returns(instance)
+      ModelFactoryTestFactory.create_model_factory_test_def(:bar => 'foo')
+    end
+  
+    should "create with no arguments and explicit defaults" do
+      instance = ModelFactoryTestDef.new
+      ModelFactoryTestDef.expects(:create!).with(:bar => 'baz').returns(instance)
+      ModelFactoryTestFactory.create_model_factory_test_def
+    end
+  
+    should "initialize with no arguments and no defaults" do
+      instance = ModelFactoryTestNoDef.new
+      ModelFactoryTestNoDef.expects(:new).returns(instance)
+      m = ModelFactoryTestFactory.new_model_factory_test_no_def
+      assert m.id > 0
+    end
+  
+    should "initialize with arguments and no defaults" do
+      instance = ModelFactoryTestNoDef.new
+      ModelFactoryTestNoDef.expects(:new).with(:bar => 'foo').returns(instance)
+      m = ModelFactoryTestFactory.new_model_factory_test_no_def(:bar => 'foo')
+      assert m.id > 0
+    end
+  
+    should "create with no arguments and no defaults" do
+      instance = ModelFactoryTestNoDef.new
+      ModelFactoryTestNoDef.expects(:create!).returns(instance)
+      ModelFactoryTestFactory.create_model_factory_test_no_def
+    end
+  
+    should "create with arguments and no defaults" do
+      instance = ModelFactoryTestNoDef.new
+      ModelFactoryTestNoDef.expects(:create!).with(:bar => 'foo').returns(instance)
+      ModelFactoryTestFactory.create_model_factory_test_no_def(:bar => 'foo')
+    end
+  end
+end
+

data/test/model_factory_test.rb

@@ -1,139 +1,86 @@
 require File.dirname(__FILE__) + '/test_helper'
+require File.dirname(__FILE__) + '/../lib/modelfactory'
 
-# The classes below are rough mocks of ActiveRecord::Base that only handle instantiation.
-
-# This class has defaults defined.
-class ModelFactoryTestDef
-  def self.protected_attributes;  nil; end
-  def self.accessible_attributes; nil; end
-  
-  attr_accessor :id, :nest, :bar, :baz
-  def initialize(opts = {})
-    opts.each do |k,v|
-      self.send("#{k}=", v)
-    end
-  end
-end
-
-# This class has no defaults defined.
-class ModelFactoryTestNoDef < ModelFactoryTestDef; end
-
-# This class has nested defaults defined.
-class ModelFactoryTestNestDef < ModelFactoryTestDef; end
-
-# This class has protected attributes.
-class ModelFactoryTestProtected < ModelFactoryTestDef
-  def self.protected_attributes; [:baz]; end
+class ModelFactoryTest < Test::Unit::TestCase
 
-  def initialize(opts = {})
-    opts = opts.clone
-    opts.delete(:baz) # Simulate a protected attribute.
-    super(opts)
+  should "not instantiate when using new" do
+    assert Widget.factory.new.new_record?
   end
-end
-
-# This class has accessible attributes.
-class ModelFactoryTestAccessible < ModelFactoryTestDef
-  def self.accessible_attributes; [:id, :nest, 'bar']; end
 
-  def initialize(opts = {})
-    opts = opts.clone
-    opts.delete(:baz) # Simulate a protected attribute.
-    super(opts)
+  should "instantiate when using create" do
+    assert !Widget.factory.create.new_record?
   end
-end
-
-# This is the testfactory class def with test defaults.
-class ModelFactoryTestFactory
-  extend ModelFactory
-  default ModelFactoryTestDef, { :bar => 'baz' }
-  default ModelFactoryTestNestDef, { :nest => default_model_factory_test_def }
-end
 
-class ModelFactoryTest < Test::Unit::TestCase
-  test "protected attributes" do
-    m = ModelFactoryTestFactory.new_model_factory_test_protected(:baz => 4)
-    assert_equal 4, m.baz
+  should "raise on creation of invalid records" do
+    assert_raises(ActiveRecord::RecordInvalid) { StrictWidget.factory.create }
   end
   
-  test "dynamic protected attributes" do
-    i = 1
-    m = ModelFactoryTestFactory.new_model_factory_test_protected(:bar => 3, :baz => lambda { i += 1 } )
-    assert_equal 2, m.baz
-  end
-
-  test "accessible attributes" do
-    m = ModelFactoryTestFactory.new_model_factory_test_accessible(:baz => 4)
-    assert_equal 4, m.baz
-  end
+  context "with a specified default that uses automatic numbering" do
+    setup do
+      ModelFactory.configure do
+        default(Widget) {|w, i| w.price = i }
+      end
+    end
   
-  test "dynamic accessible attributes" do
-    i = 1
-    m = ModelFactoryTestFactory.new_model_factory_test_accessible(:bar => 3, :baz => lambda { i += 1 } )
-    assert_equal 2, m.baz
-  end
-
-  test "new with no arguments and nested defaults" do
-    m = ModelFactoryTestFactory.new_model_factory_test_nest_def
-    assert m.nest.id > 0
-    assert m.id > 0
-  end
-
-  test "new with arguments and nested defaults" do
-    m = ModelFactoryTestFactory.new_model_factory_test_nest_def(:bar => 'foo')
-    assert_equal 'foo', m.bar
-    assert m.nest.id > 0
-    assert m.id > 0
-  end
-
-  test "new with no arguments and explicit defaults" do
-    m = ModelFactoryTestFactory.new_model_factory_test_def
-    assert_equal 'baz', m.bar
-    assert m.id > 0
-  end
-
-  test "new with arguments and explicit defaults" do
-    m = ModelFactoryTestFactory.new_model_factory_test_def(:bar => 'foo')
-    assert_equal 'foo', m.bar
-    assert m.id > 0
-  end
-
-  test "create with arguments and explicit defaults" do
-    instance = ModelFactoryTestDef.new
-    ModelFactoryTestDef.expects(:create!).with(:bar => 'foo').returns(instance)
-    ModelFactoryTestFactory.create_model_factory_test_def(:bar => 'foo')
-  end
-
-  test "create with no arguments and explicit defaults" do
-    instance = ModelFactoryTestDef.new
-    ModelFactoryTestDef.expects(:create!).with(:bar => 'baz').returns(instance)
-    ModelFactoryTestFactory.create_model_factory_test_def
-  end
-
-  test "new with no arguments and no defaults" do
-    instance = ModelFactoryTestNoDef.new
-    ModelFactoryTestNoDef.expects(:new).returns(instance)
-    m = ModelFactoryTestFactory.new_model_factory_test_no_def
-    assert m.id > 0
-  end
+    should "start counting at 1 after configuration" do
+      assert_equal 1.0, Widget.factory.create.price
+    end
 
-  test "new with arguments and no defaults" do
-    instance = ModelFactoryTestNoDef.new
-    ModelFactoryTestNoDef.expects(:new).with(:bar => 'foo').returns(instance)
-    m = ModelFactoryTestFactory.new_model_factory_test_no_def(:bar => 'foo')
-    assert m.id > 0
+    should "generate a unique sequence" do
+      w = []
+      3.times { w << Widget.factory.create.price }
+      assert_equal w.uniq, w
+    end
   end
 
-  test "create with no arguments and no defaults" do
-    instance = ModelFactoryTestNoDef.new
-    ModelFactoryTestNoDef.expects(:create!).returns(instance)
-    ModelFactoryTestFactory.create_model_factory_test_no_def
+  context "with a specified default" do
+    setup do
+      ModelFactory.configure do
+        default(Widget) {|w| w.name = 'foobaz' }
+      end
+    end
+  
+    should "initialize defaults with no arguments" do
+      assert_equal 'foobaz', Widget.factory.create.name
+    end
+  
+    should "initialize defaults with an unspecified argument" do
+      assert_equal 'foobaz', Widget.factory.create(:price => 4.0).name
+    end
+  
+    should "initialize with an unspecified argument" do
+      assert_equal 4, Widget.factory.create(:price => 4.0).price
+    end
   end
 
-  test "create with arguments and no defaults" do
-    instance = ModelFactoryTestNoDef.new
-    ModelFactoryTestNoDef.expects(:create!).with(:bar => 'foo').returns(instance)
-    ModelFactoryTestFactory.create_model_factory_test_no_def(:bar => 'foo')
+  context "with a named factory" do
+    setup do
+      ModelFactory.configure do
+        default(Widget) {|w| w.name = 'wubbo' }
+        favorite(Widget) {|w| w.name = 'foobaz' }
+      end
+    end
+  
+    should "not apply named config to default" do
+      assert_equal 'wubbo', Widget.factory.create.name
+    end
+  
+    should "not apply any config to unrecognized name" do
+      assert_equal nil, Widget.factory.create_emptyfoo.name
+    end
+  
+    should "initialize defaults with no arguments" do
+      assert_equal 'foobaz', Widget.factory.create_favorite.name
+    end
+  
+    should "initialize defaults with an unspecified argument" do
+      assert_equal 'foobaz', Widget.factory.create_favorite(:price => 4.0).name
+    end
+  
+    should "initialize with an unspecified argument" do
+      assert_equal 4, Widget.factory.create_favorite(:price => 4.0).price
+    end
   end
 end
 
+

data/test/test_helper.rb

@@ -1,12 +1,22 @@
 require 'test/unit'
 require 'rubygems'
 require 'mocha'
-require File.dirname(__FILE__) + '/../lib/model_factory'
+require 'shoulda'
 
-class << Test::Unit::TestCase
-  def test(name, &block)
-    test_name = "test_#{name.gsub(/[\s\W]/,'_')}"
-    raise ArgumentError, "#{test_name} is already defined" if self.instance_methods.include? test_name
-    define_method test_name, &block
-  end
+require 'active_record'
+ActiveRecord::Base.establish_connection(
+  :database => ':memory:',
+  :adapter  => 'sqlite3',
+  :timeout  => 500
+)
+
+require 'active_record/fixtures'
+require 'test/fixtures/schema.rb'
+class Test::Unit::TestCase
+  FIXTURES_PATH = File.join(File.dirname(__FILE__), '/fixtures')
+  dep = defined?(ActiveSupport::Dependencies) ?
+    ActiveSupport::Dependencies :
+    ::Dependencies
+  dep.load_paths.unshift FIXTURES_PATH
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: modelfactory
 version: !ruby/object:Gem::Version 
-  version: 0.8.1
+  version: 0.8.9
 platform: ruby
 authors: 
 - Justin Balthrop
@@ -10,9 +10,49 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-08 00:00:00 -07:00
+date: 2009-05-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: active_record
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   type: :development
@@ -42,12 +82,19 @@ files:
 - Rakefile
 - lib/fixture_converter.rb
 - lib/model_factory.rb
-- lib/model_factory/version.rb
+- lib/modelfactory.rb
+- lib/modelfactory/factory.rb
+- lib/modelfactory/legacy.rb
+- lib/modelfactory/version.rb
 - script/destroy
 - script/fixtures2factories
 - script/generate
 - script/txt2html
 - setup.rb
+- test/fixtures/schema.rb
+- test/fixtures/strict_widget.rb
+- test/fixtures/widget.rb
+- test/model_factory_legacy_test.rb
 - test/model_factory_test.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -79,3 +126,4 @@ specification_version: 2
 summary: A replacement for fixtures.
 test_files: 
 - test/model_factory_test.rb
+- test/model_factory_legacy_test.rb