modelizer 4.0.0 → 5.0.0

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+=== 5.0.0 / 2011-09-11
+
+* Complete breaking change, now provides unified fixtures/factories.
+* Require Ruby 1.9.2 or better.
+
 === 4.0.0 / 2011-06-14
 
 * Update for AR 3.1.

data/Manifest.txt

@@ -4,7 +4,7 @@ Manifest.txt
 README.rdoc
 Rakefile
 lib/modelizer.rb
+lib/modelizer/all.rb
 lib/modelizer/assertions.rb
 lib/modelizer/validations.rb
 test/test_assertions.rb
-test/test_modelizer.rb

data/README.rdoc

@@ -5,72 +5,84 @@
 == Description
 
 Need a simple, consistent way to create model instances and check
-validations in your ActiveRecord 3.1+ tests? Use the Modelizer.
+validations in your ActiveRecord 3.1+ tests? Use the Modelizer. Just
+don't trust the docs, since lots changed in 5.x and I got lazy.
 
 == Examples
 
-First, enable the Modelizer. I do it in <tt>test/test_helper.rb</tt>:
+First, enable the Modelizer in your test helper. In Rails, try
+something like:
+
+    require "modelizer/all"
 
     class ActiveSupport::TestCase
       include Modelizer
+      extend  Modelizer::Validations
     end
 
-Next, define a model template. I generally do this in the unit test
-for the model until I need to use the template somewhere else. As soon
-as it's used in multiple places, I move it to a reopened
-<tt>ActiveSupport::TestCase</tt> in <tt>test/test_helper.rb</tt>.
+Next, define some fixtures and factories. Modelizer will load these
+when the module is included, using
+<tt>"test/{factories,fixtures}/**/*.rb"</tt> as a default glob. Change
+it by setting <tt>Modelizer.glob</tt> before module inclusion.
+
+Fixture and factory definitions look remarkably similar. The only real
+difference is that fixtures get loaded into the DB once at module
+inclusion and factories don't. Factories will also generally use
+autogenerated/random data generators. Some examples:
+
+    # from test/fixtures/user.rb
 
-    class UserTest < ActiveSupport::TestCase
+    fixture :user, User do |u|
+      u.account  = use :account
+      u.email    = "default@example.org
+      u.name     = "A User"
+      u.password = "123456"
+      u.state    = "active"
+    end
 
-      # a simple list of attributes
-      model_template_for User, :name => "Bob"
 
-      # or a block for lazy evaluation
-      model_template_for User do
-        { :name => "Bob", :address => addresses(:default) }
-      end
+    # from test/factories/user.rb
 
+    factory :user, User do |u|
+      u.account  = use :account
+      u.email    = Faker::Internet.email
+      u.name     = Faker::Name.name
+      u.password = Faker::Lorem.words(1).first
     end
 
-This declaration generates a bunch of instance methods for you:
+To get a reference to a fixture, the <tt>use</tt> method is added to your
+test class:
+
+    def test_something
+      refute_equal use(:artist).name, use("artist/child").name
+    end
 
-* <tt>def valid_user_attributes(extras = {})</tt>
-* <tt>def valid_user_attributes_without(*excluded)</tt>
-* <tt>def new_user(extras = {})</tt>
-* <tt>def new_user_without(*excluded)</tt>
-* <tt>def create_user(extras = {})</tt>
-* <tt>def create_user!(extras = {})</tt>
-* <tt>def create_user_without(*excluded)</tt>
-* <tt>def create_user_without!(*excluded)</tt>
+To get an instance from a factory, the <tt>build</tt> and <tt>create</tt> methods
+are available:
 
-It also generates a test to make sure your model template is valid.
+    def test_something_else
+      assert_equal "foo", build(:artist, name: "foo").name
+      refute create(:artist).new_record?
+    end
 
 === Custom Assertions
 
-Modelizer adds one additional assertion, <tt>assert_invalid</tt>.
+If you require <tt>"modelizer/all"</tt> or include
+<tt>Modelizer::Assertions</tt>, Modelizer adds one additional
+assertion, <tt>assert_invalid</tt>.
 
     assert_invalid :email, model, /is bad/
 
 The third argument is optional.
 
-=== Using in Tests
-
-    class UserTest < ActiveSupport::TestCase
-      model_template_for User, :name => "Bob"
-
-      def test_pointless_stuff
-        assert new_user.valid?
-        assert_invalid :name, new_user_without(:name)
-
-        assert !create_user.new_record?
+    def test_pointless_stuff
+      assert new_user.valid?
+      assert_invalid :name, build(:artist, name: nil)
+    end
 
-        assert_raise do
-          create_user_without! :name
-        end
+=== Testing Validations
 
-        assert_equal "Fred", new_user(:name => "Fred").name
-      end
-    end
+I should really write some docs for this.
 
 == Installation
 

data/Rakefile

@@ -10,4 +10,6 @@ Hoe.spec "modelizer" do
   self.history_file     = "CHANGELOG.rdoc"
   self.readme_file      = "README.rdoc"
   self.testlib          = :minitest
+
+  require_ruby_version ">= 1.9.2"
 end

data/lib/modelizer.rb

@@ -1,138 +1,102 @@
-require "modelizer/assertions"
-require "modelizer/validations"
+require "zlib"
 
 module Modelizer
 
-  # Duh.
-  VERSION = "4.0.0"
+  VERSION = "5.0.0"
 
-  include Modelizer::Assertions
+  def build name, overrides = nil, &block
+    model, *initializers = Modelizer.factories[name]
+    raise "Can't find the \"#{name}\" factory." unless model
 
-  # Test classes that should be considered abstract when rendering
-  # tests for a model template.
+    obj = model.new
 
-  TEST_CLASSES = []
+    initializers << block if block_given?
+    initializers.each { |i| instance_exec obj, &i }
 
-  %w(Test::Unit::TestCase Minitest::Unit::TestCase
-     ActiveSupport::TestCase).each do |k|
+    overrides.each { |k, v| obj.send "#{k}=", v } if overrides
+    
+    obj
+  end
+
+  def create name, overrides = nil, &block
+    obj = build name, overrides, &block
+
+    obj.save!
 
-    TEST_CLASSES <<
-      k.split("::").inject(Object) { |a, b| a.const_get b } rescue nil
+    obj
   end
 
-  @@cache = {}
-  def self.cache; @@cache end
+  def use name
+    model, id = Modelizer.ids[name]
+    raise "Can't find the \"#{name}\" fixture." unless model
 
-  def self.included target
-    target.extend ClassMethods
-    target.extend Modelizer::Validations
+    model.find id
   end
 
-  def self.method_name_for model_class
-    underscore model_class.name
+  class Context < Struct.new(:instances)
+    def identify name
+      Modelizer.identify name
+    end
+
+    def use name
+      instances[name] or raise "Can't find the \"#{name}\" fixture."
+    end
   end
 
-  def self.model_class_for test_class
-    test_class.name.gsub(/Test$/, "").constantize
+  def self.included klass
+    Dir[glob].sort.each { |f| instance_eval File.read(f), f, 1 }
+
+    instances = {}
+    context   = Context.new instances
+
+    fixtures.each do |name, value|
+      instances[name] = value.first.new
+    end
+
+    instances.each do |name, obj|
+      _, *initializers = fixtures[name]
+      initializers.each { |i| context.instance_exec obj, &i }
+
+      obj.id    = identify name
+      ids[name] = [obj.class, obj.id]
+    end
+
+    ActiveRecord::Base.transaction do
+      instances.each { |_, obj| obj.save! }
+    end
   end
 
-  def self.underscore classname
-    classname.gsub(/::/, '_').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
+  class << self
+    attr_accessor :glob
   end
 
-  def assign_model_template_attributes model, attributes
-    model.assign_attributes attributes, without_protection: true
-    model
+  self.glob = "test/{factories,fixtures}/**/*.rb"
+
+  def self.cache
+    @cache ||= {}
   end
 
-  def valid_model_template_attributes klass, extras = {}
-    defaults, block = ::Modelizer.cache[klass]
-    lazy = block && instance_eval(&block)
-    [defaults, lazy, extras].compact.inject { |t, s| t.merge s }
+  def self.factory name, model, &initializer
+    factories[name] = [model, initializer]
   end
 
-  def valid_model_template_attributes_without klass, excluded
-    valid_model_template_attributes(klass).delete_if do |k, v|
-      excluded.include? k
-    end
+  def self.factories
+    @factories ||= {}
   end
 
-  module ClassMethods
-    def model_template_for klass, defaults = {}, &block
-      if defaults.nil? && !block
-        raise ArgumentError, "default attributes or lazy block required"
-      end
-
-      ::Modelizer.cache[klass] = [defaults, block]
-
-      model = ::Modelizer.method_name_for klass
-      klass = klass.name
-
-      module_eval <<-END, __FILE__, __LINE__ + 1
-        def valid_#{model}_attributes extras = {}
-          valid_model_template_attributes #{klass}, extras
-        end
-
-        def valid_#{model}_attributes_without *excluded
-          valid_model_template_attributes_without #{klass}, excluded
-        end
-
-        def new_#{model} extras = {}
-          assign_model_template_attributes #{klass}.new,
-            valid_model_template_attributes(#{klass}, extras)
-        end
-
-        def new_#{model}_without *excluded
-          assign_model_template_attributes #{klass}.new,
-            valid_model_template_attributes_without(#{klass}, excluded)
-        end
-
-        def create_#{model} extras = {}
-          (m = new_#{model}(extras)).save; m
-        end
-
-        def create_#{model}! extras = {}
-          (m = new_#{model}(extras)).save!; m
-        end
-
-        def create_#{model}_without *excluded
-          (m = new_#{model}_without(*excluded)).save; m
-        end
-
-        def create_#{model}_without! *excluded
-          (m = new_#{model}_without(*excluded)).save!; m
-        end
-      END
-
-      # Install a test that ensures the model template is valid. If
-      # the template is defined in one of the abstract test
-      # superclasses, generate a whole new testcase. If it's in a
-      # concrete test, just generate a method.
-
-      file, line = caller.first.split ":"
-      line = line.to_i
-
-      test = <<-END
-        def test_model_template_for_#{model}
-          assert (m = new_#{model}).valid?,
-            "#{klass} template is invalid: " +
-              m.errors.full_messages.to_sentence
-        end
-      END
-
-      if TEST_CLASSES.include? self
-        eval <<-END, nil, file, line - 2
-          class ::ModelTemplateFor#{klass}Test < ActiveSupport::TestCase
-            #{test}
-          end
-        END
-      else
-        module_eval test, file, line - 1
-      end
-    end
+  def self.fixture name, model, &initializer
+    fixtures[name] = [model, initializer]
+  end
+
+  def self.fixtures
+    @fixtures ||= {}
+  end
+
+  def self.identify name
+    Zlib.crc32(name.to_s) % (2 ** 30 - 1)
+  end
+
+  def self.ids
+    @ids ||= {}
   end
 end

data/lib/modelizer/all.rb

@@ -0,0 +1,3 @@
+require "modelizer"
+require "modelizer/assertions"
+require "modelizer/validations"

data/lib/modelizer/assertions.rb

@@ -13,4 +13,6 @@ module Modelizer
       assert_match match, model.errors.on(attribute) if match
     end
   end
+
+  include Assertions
 end

data/lib/modelizer/validations.rb

@@ -1,36 +1,23 @@
 module Modelizer
   module Validations
-    def test_validations_for attribute, *validations
-      @klass ||= ::Modelizer.model_class_for self
-      @model ||= ::Modelizer.method_name_for @klass
-
-      unless instance_methods.collect { |m| m.to_s }.include? "new_#{@model}"
-        raise "no model template for #{@klass.name}"
-      end
-
-      # FIX: location in original test file
-
-      validations.each do |v|
-        test = send "validation_lambda_for_#{v}", @klass, @model, attribute
-        define_method "test_#{attribute}_#{v}", &test
+    def test_presence_for plan, attribute
+      define_method "test_#{attribute}_presence" do
+        bad = build plan, attribute => nil
+        assert_invalid attribute, bad
       end
     end
 
-    private
-
-    def validation_lambda_for_presence klass, model, attribute
-      lambda do
-        assert_invalid attribute, send("new_#{model}", attribute => nil)
+    def test_uniqueness_for plan, attribute
+      define_method "test_#{attribute}_uniqueness" do
+        good = create plan
+        bad  = build(plan) { |o| o.send("#{attribute}=", good.send(attribute)) }
+        assert_invalid attribute, bad
       end
     end
 
-    def validation_lambda_for_uniqueness klass, model, attribute
-      lambda do
-        existing = klass.first
-        assert existing, "There's at least one #{model} fixture."
-
-        assert_invalid attribute,
-          send("new_#{model}", attribute => existing.send(attribute))
+    def test_validations_for plan, attribute, *validations
+      validations.each do |validation|
+        send "test_#{validation}_for", plan, attribute
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: modelizer
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-14 00:00:00.000000000 -05:00
-default_executable: 
+date: 2011-09-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe
-  requirement: &2151797440 !ruby/object:Gem::Requirement
+  requirement: &70235549949760 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.9.4
+        version: '2.12'
   type: :development
   prerelease: false
-  version_requirements: *2151797440
+  version_requirements: *70235549949760
 description: ! 'Need a simple, consistent way to create model instances and check
 
-  validations in your ActiveRecord 3.1+ tests? Use the Modelizer.'
+  validations in your ActiveRecord 3.1+ tests? Use the Modelizer. Just
+
+  don''t trust the docs, since lots changed in 5.x and I got lazy.'
 email:
 - code@jbarnette.com
 executables: []
@@ -41,12 +42,11 @@ files:
 - README.rdoc
 - Rakefile
 - lib/modelizer.rb
+- lib/modelizer/all.rb
 - lib/modelizer/assertions.rb
 - lib/modelizer/validations.rb
 - test/test_assertions.rb
-- test/test_modelizer.rb
 - .gemtest
-has_rdoc: true
 homepage: http://github.com/jbarnette/modelizer
 licenses: []
 post_install_message: 
@@ -60,7 +60,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -69,11 +69,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: modelizer
-rubygems_version: 1.6.2
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: Need a simple, consistent way to create model instances and check validations
-  in your ActiveRecord 3.1+ tests? Use the Modelizer.
+  in your ActiveRecord 3.1+ tests? Use the Modelizer
 test_files:
 - test/test_assertions.rb
-- test/test_modelizer.rb

data/test/test_modelizer.rb

@@ -1,14 +0,0 @@
-require "minitest/autorun"
-require "modelizer"
-
-class TestModelizer < MiniTest::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @klass.send :include, Modelizer
-  end
-
-  def test_adds_model_template_for_class_method
-    assert_includes @klass.singleton_methods.collect { |m| m.to_s },
-      "model_template_for"
-  end
-end