fakutori-san 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+rdoc

data/.kick

@@ -0,0 +1,12 @@
+recipe :ruby
+
+process do |files|
+  Ruby.run_tests(files.take_and_map do |file|
+    case file
+    when %r{^lib/(.*).rb$}
+      "test/#{$1.gsub('/', '_')}_test.rb"
+    when 'test/test_helper.rb'
+      Dir.glob('test/*_test.rb')
+    end
+  end)
+end

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright © 2009
+  Eloy Duran, Fingertips <eloy@fngtps.com>
+  Manfred Stienstra, Fingertips <manfred@fngtps.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,41 @@
+= Fakutori-San
+
+Fakutori-San is an instance factory for your tests. Factories in Fakutori-San
+are plain Ruby classes. It uses a number of naming rules, not magic, to do
+smart things. This means you can use class inheritance and other standard
+Ruby practices to define your factories.
+
+Although Fakutori-San was written to be used in Rails with ActiveRecord it
+only assumes the save method to persist the object. If your objects also
+persist themselves with the save method you're golden.
+
+== Short example
+
+Fakutori-San uses some smart assumptions about methods in your factory class
+so you can easily define all types of situations for your model.
+
+  module FakutoriSan
+    class MemberFakutori < Fakutori
+      def valid_attrs
+        { 'name' => 'Eloy', 'email' => 'eloy@example.com', 'password' => 'secret' }
+      end
+    
+      def invalid_attrs
+        { 'name' => '' }
+      end
+    end
+  end
+
+After you've defined a factory for your model you can instantiate it, for
+instance in the setup method of your test.
+
+  @valid_member = Fakutori(Member).create_one
+  @invalid_member = Fakutori(Member).create_one(:invalid)
+
+Fakutori-San looks for a class called FakutoriSan::MemberFakutori to create a
+Member instance. It also knows that it should use invalid_attrs when creating
+an invalid member. Neat huh?
+
+If you want to learn more about Fakutori-San, please check out the examples,
+the tests, and the implementation. Note that the code is not that long so it's
+not a chore.

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the fakutori-san plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the fakutori-san plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fakutori-san'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=utf8'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "fakutori-san"
+    s.homepage = "http://github.com/Fingertips/fakutori-san"
+    s.email    = "eloy.de.enige@gmail.com"
+    s.authors  = ["Eloy Duran"]
+    s.summary  = s.description = "FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc."
+  end
+rescue LoadError
+end
+ 
+begin
+  require 'jewelry_portfolio/tasks'
+  JewelryPortfolio::Tasks.new do |p|
+    p.account = 'Fingertips'
+  end
+rescue LoadError
+end

data/TODO

@@ -0,0 +1,10 @@
+* Add scenario blocks which allow you to add a description to a set of Fakutori calls
+
+  scenario 'Calendar with events in multiple venues' do
+    Fakutori(Event).create!(:venue => venues(:melkweg))
+    Fakutori(Event).create!(:venue => venues(:paradiso))
+  end
+
+* Speed up definition of scenarios by somehow dumping the contents of a scenario
+* Invalidate the scenario cache when the file in which it was defined changes
+* Fakutori should circumvent attr_accessible / attr_protected so it's easier to initialize models the way you want them

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/examples/simple_factory.rb

@@ -0,0 +1,39 @@
+require 'faker' # For more information about Faker, see http://faker.rubyforge.org
+
+# Always define your factories in the FakutoriSan module so they don't mix
+# interfere with the rest of your code and FakutoriSan can find them.
+module FakutoriSan
+  # Factories always subclass from Fakutori
+  class Article < Fakutori
+    # When creating a new object, Fakutori-San will always use the valid_attrs method by default.
+    def valid_attrs
+      { :title => Faker::Lorem.words.join(' '), :body => Faker::Lorem.paragraphs.join("\n\n") }
+    end
+    
+    def invalid_attrs
+      { :title => '', :body => '' }
+    end
+  end
+end
+
+# After defining a factory you can plan, build, or create objects
+
+# The plan method returns attributes from the factory
+article_atributes = Fakutori(Article).plan
+# The build method uses attributes from factory to instantiate an object
+article = Fakutori(Article).build
+# The create method builds the object and saves it
+article = Fakutori(Article).create
+
+# The plan, build, and create methods do smart things with their arguments.
+
+# Use a different set of attributes to build
+article = Fakutori(Article).build(:invalid)
+# Override default attributes with your own custom ones
+article = Fakutori(Article).build(:title => 'Breaking Bad')
+# Build three articles
+articles = Fakutori(Article).build(3)
+# Build three invalid articles
+articles = Fakutori(Article).build(3, :invalid)
+# Build three invalid articles with a specified body
+articles = Fakutori(Article).build(3, :invalid, :body => "Hi, I'm invalid") 

data/fakutori-san.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fakutori-san}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Eloy Duran"]
+  s.date = %q{2010-10-01}
+  s.description = %q{FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.}
+  s.email = %q{eloy.de.enige@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc",
+     "TODO"
+  ]
+  s.files = [
+    ".gitignore",
+     ".kick",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION.yml",
+     "examples/simple_factory.rb",
+     "fakutori-san.gemspec",
+     "lib/fakutori_san.rb",
+     "lib/fakutori_san/fakutori.rb",
+     "rails/init.rb",
+     "test/factories/foo_fakutori.rb",
+     "test/factories/member_fakutori.rb",
+     "test/fakutori_san_fakutori_test.rb",
+     "test/fakutori_san_test.rb",
+     "test/models/article.rb",
+     "test/models/member.rb",
+     "test/models/namespaced/article.rb",
+     "test/models/unrelated.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/Fingertips/fakutori-san}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.}
+  s.test_files = [
+    "test/factories/foo_fakutori.rb",
+     "test/factories/member_fakutori.rb",
+     "test/fakutori_san_fakutori_test.rb",
+     "test/fakutori_san_scenarios_test.rb",
+     "test/fakutori_san_test.rb",
+     "test/models/article.rb",
+     "test/models/member.rb",
+     "test/models/namespaced/article.rb",
+     "test/models/unrelated.rb",
+     "test/test_helper.rb",
+     "examples/simple_factory.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/fakutori_san.rb

@@ -0,0 +1,15 @@
+require 'fakutori_san/fakutori'
+require 'fakutori_san/scenarios'
+
+# FakutoriSan is the module where most of the implementation resides.
+module FakutoriSan
+end
+
+module Kernel
+  # The Fakutori method is used to instantiate your factories. For more information about defining
+  # and using factories see FakutoriSan::Fakutori and the examples.
+  def Fakutori(model)
+    FakutoriSan.factories[model] || raise(FakutoriSan::FakutoriMissing, "No factory defined for model `#{model}'")
+  end
+  private :Fakutori
+end

data/lib/fakutori_san/fakutori.rb

@@ -0,0 +1,154 @@
+module FakutoriSan
+  class FakutoriMissing < NameError; end
+  
+  # Returns a hash of the available <tt>model => factory</tt> pairs.
+  def self.factories
+    @factories ||= {}
+  end
+  
+  module FakutoriExt
+    def associate_to(model, options = nil)
+      @__factory__.associate(self, model, options)
+      self
+    end
+    
+    def apply_scene(name, options = {})
+      @__factory__.scene(name, self, options)
+    end
+  end
+  
+  class Collection < Array
+    include FakutoriExt
+    
+    def initialize(factory, times)
+      @__factory__ = factory
+      super(times)
+    end
+    
+    def factory
+      @__factory__
+    end
+  end
+  
+  class Fakutori
+    class << self
+      def inherited(factory_klass)
+        model_klass = Object.const_get(factory_klass.name.gsub(/^FakutoriSan::|Fakutori$/, ''))
+        factory_klass.for_model model_klass
+      rescue NameError
+      end
+      
+      def for_model(model)
+        FakutoriSan.factories[model] = new(model)
+      end
+    end
+    
+    attr_reader :model
+    
+    def initialize(model)
+      @model = model
+    end
+    
+    def plan_one(*type_and_or_attributes)
+      attributes = type_and_or_attributes.extract_options!
+      type = type_and_or_attributes.pop || :valid
+      m = "#{type}_attrs"
+      
+      if respond_to?(m)
+        plan = method(m).arity.zero? ? send(m) : send(m, attributes)
+        plan.merge(attributes)
+      else
+        raise NoMethodError, "#{self.class.name} has no attributes method for type `#{type}'"
+      end
+    end
+    
+    def plan(*times_and_or_type_and_or_attributes)
+      multiple_times :plan, times_and_or_type_and_or_attributes
+    end
+    
+    def build_one(*type_and_or_attributes)
+      make_chainable(@model.new(plan_one(*type_and_or_attributes)))
+    end
+    
+    def build(*times_and_or_type_and_or_attributes)
+      multiple_times :build, times_and_or_type_and_or_attributes
+    end
+    
+    def create_one(*type_and_or_attributes_and_or_validate)
+      args = type_and_or_attributes_and_or_validate
+      
+      validate = args.pop if [true, false].include?(args.last)
+      instance = build_one(*args)
+      validate ? instance.save! : instance.save(false)
+      instance
+    end
+    
+    def create_one!(*type_and_or_attributes)
+      type_and_or_attributes << true
+      create_one(*type_and_or_attributes)
+    end
+    
+    def create(*times_and_or_type_and_or_attributes)
+      multiple_times :create, times_and_or_type_and_or_attributes
+    end
+    
+    def create!(*times_and_or_type_and_or_attributes)
+      times_and_or_type_and_or_attributes << true
+      create(*times_and_or_type_and_or_attributes)
+    end
+    
+    def associate(record_or_collection, to_model, options = nil)
+      if builder = association_builder_for(to_model)
+        [*record_or_collection].each do |record|
+          send(*[builder, record, to_model, options].compact)
+        end
+      else
+        raise NoMethodError, "#{self.class.name} has no association builder method for model `#{to_model.inspect}'."
+      end
+      
+      record_or_collection
+    end
+    
+    def scene(name, record_or_collection, options = {})
+      method = "#{name}_scene"
+      unless respond_to?(method)
+        raise NoMethodError, "#{self.class.name} has no scene method for scene `#{name.inspect}'"
+      end
+      
+      if record_or_collection.is_a?(Array)
+        record_or_collection.each_with_index do |record, index|
+          options[:index] = index
+          send(method, record, options)
+        end
+      else
+        send(method, record_or_collection, options)
+      end
+      
+      record_or_collection
+    end
+    
+    private
+    
+    def make_chainable(instance)
+      instance.extend(FakutoriExt)
+      instance.instance_variable_set(:@__factory__, self)
+      instance
+    end
+    
+    def multiple_times(type, args)
+      m = "#{type}_one"
+      
+      if args.first.is_a?(Numeric)
+        Collection.new(self, args.shift) { send(m, *args) }
+      else
+        send(m, *args)
+      end
+    end
+    
+    def association_builder_for(model)
+      klass = model.is_a?(Class) ? model : model.class
+      name = "associate_to_#{klass.name.underscore.gsub('/', '_')}".to_sym
+      name if respond_to?(name)
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'fakutori_san'

data/test/factories/foo_fakutori.rb

@@ -0,0 +1,5 @@
+module FakutoriSan
+  class FooFakutori < Fakutori
+    for_model Article
+  end
+end

data/test/factories/member_fakutori.rb

@@ -0,0 +1,29 @@
+module FakutoriSan
+  class MemberFakutori < Fakutori
+    def valid_attrs
+      { 'name' => 'Eloy', 'email' => 'eloy@example.com', 'password' => 'secret' }
+    end
+    
+    def minimal_attrs
+      { 'name' => 'Eloy' }
+    end
+    
+    def invalid_attrs
+      {}
+    end
+    
+    def with_arg_attrs(arg)
+      { 'arg' => arg }
+    end
+    
+    def with_name_scene(member, options)
+      member.update_attribute :name, "#{options[:name]}#{options[:index]}"
+    end
+    
+    def associate_to_article(member, article, options)
+    end
+    
+    def associate_to_namespaced_article(member, article, options)
+    end
+  end
+end

data/test/fakutori_san_fakutori_test.rb

@@ -0,0 +1,305 @@
+require File.expand_path('../test_helper', __FILE__)
+
+module SharedSpecsHelper
+  def define_shared_specs_for(type)
+    it "should call ##{type}_one multiple times and return an array of the resulting attribute hashes" do
+      attributes = { 'name' => 'Eloy' }
+      
+      @factory.expects("#{type}_one").with(attributes).times(2).returns({})
+      @factory.send(type, 2, attributes).should == [{}, {}]
+      
+      @factory.expects("#{type}_one").with(:minimal, attributes).times(2).returns({})
+      @factory.send(type, 2, :minimal, attributes).should == [{}, {}]
+    end
+    
+    it "should not call ##{type}_one multiple times if no `times' argument is given" do
+      attributes = { 'name' => 'Eloy' }
+      
+      @factory.expects("#{type}_one").with(attributes).times(1).returns({})
+      @factory.send(type, attributes).should == {}
+      
+      @factory.expects("#{type}_one").with(:minimal, attributes).times(1).returns({})
+      @factory.send(type, :minimal, attributes).should == {}
+    end
+    
+    it "should return a FakutoriSan::Collection instance when a collection is created" do
+      collection = @factory.send(type, 2)
+      collection.should.be.instance_of FakutoriSan::Collection
+      collection.factory.should.be @factory
+    end
+    
+    unless type == :plan
+      it "should extend each instance returned by FakutoriSan with the FakutoriSan::FakutoriExt module" do
+        instance = @factory.create_one
+        FakutoriSan::FakutoriExt.instance_methods.each do |method|
+          instance.should.respond_to method
+        end
+      end
+    end
+  end
+end
+Test::Unit::TestCase.send(:extend, SharedSpecsHelper)
+
+describe "FakutoriSan::Fakutori, concerning setup" do
+  it "should automatically find the model class based on the factory class's name and initialize an instance the factory subclass" do
+    factory = FakutoriSan.factories[Member]
+    factory.should.be.instance_of FakutoriSan::MemberFakutori
+    factory.model.should.be Member
+  end
+  
+  it "should allow a user to explicitly define the model class when automatically finding the right class fails" do
+    factory = FakutoriSan.factories[Article]
+    factory.should.be.instance_of FakutoriSan::FooFakutori
+    factory.model.should.be Article
+  end
+end
+
+describe "The top level Fakutori method" do
+  it "should return the factory belonging to the given model" do
+    Fakutori(Member).should.be FakutoriSan.factories[Member]
+    Fakutori(Article).should.be FakutoriSan.factories[Article]
+  end
+  
+  it "should raise a FakutoriSan::FakutoriMissing exception if no factory can be found" do
+    lambda {
+      Fakutori(Unrelated)
+    }.should.raise FakutoriSan::FakutoriMissing
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `planning'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :plan
+  
+  it "should return a hash of attributes" do
+    @factory.plan_one.should == { 'name' => 'Eloy', 'email' => 'eloy@example.com', 'password' => 'secret' }
+  end
+  
+  it "should merge the given attributes onto the resulting attributes hash" do
+    @factory.plan_one('name' => 'Alloy', 'password' => 'supersecret').should ==
+      { 'name' => 'Alloy', 'email' => 'eloy@example.com', 'password' => 'supersecret' }
+  end
+  
+  it "should pass the attributes hash to the `plan' method" do
+    @factory.plan_one(:with_arg, 'name' => 'Eloy').should ==
+      { 'name' => 'Eloy', 'arg' => { 'name' => 'Eloy' } }
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    @factory.plan_one(:minimal).should == { 'name' => 'Eloy' }
+    @factory.plan_one(:minimal, 'email' => 'eloy@example.com').should == { 'name' => 'Eloy', 'email' => 'eloy@example.com' }
+  end
+  
+  it "should raise a NoMethodError if given a attributes type for which no method exists" do
+    lambda { @factory.plan_one(:unexisting) }.should.raise NoMethodError
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `building'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :build
+  
+  it "should build one instance with the default plan" do
+    instance = @factory.build_one
+    instance.should.be.new_record
+    instance.attributes.should == @factory.plan_one
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    instance = @factory.build_one(:minimal)
+    instance.should.be.new_record
+    instance.attributes.except('password', 'email').should == @factory.plan_one(:minimal)
+    
+    instance = @factory.build_one(:minimal, 'email' => 'eloy@example.com')
+    instance.should.be.new_record
+    instance.attributes.except('password').should == @factory.plan_one(:minimal, 'email' => 'eloy@example.com')
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `creating'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :create
+  
+  it "should create one instance with the default plan" do
+    instance = @factory.create_one
+    instance.should.not.be.new_record
+    instance.attributes.except('id').should == @factory.plan_one
+  end
+  
+  it "should not perform validations by default" do
+    instance = @factory.create_one(:invalid)
+    instance.should.not.be.new_record
+    instance.should.not.be.valid
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    instance = @factory.create_one(:minimal)
+    instance.should.not.be.new_record
+    instance.attributes.except('id', 'password', 'email').should == @factory.plan_one(:minimal)
+    
+    instance = @factory.create_one(:minimal, 'email' => 'eloy@example.com')
+    instance.should.not.be.new_record
+    instance.attributes.except('id', 'password').should == @factory.plan_one(:minimal, 'email' => 'eloy@example.com')
+  end
+  
+  it "should perform validations and raise an exception if created with #create_one!" do
+    lambda {
+      @factory.create_one!(:invalid)
+    }.should.raise ActiveRecord::RecordInvalid
+    
+    lambda {
+      instance = @factory.create_one!(:minimal, 'password' => '12345')
+      instance.attributes.except('id', 'email').should == @factory.plan_one(:minimal, 'password' => '12345')
+    }.should.not.raise ActiveRecord::RecordInvalid
+  end
+  
+  it "should call #create_one multiple times and perform validations, and return an array of the resulting record instances" do
+    attributes = { 'name' => 'Eloy' }
+    
+    @factory.expects(:create_one).with(attributes, true).times(2).returns({})
+    @factory.create!(2, attributes)
+    
+    @factory.expects(:create_one).with(:minimal, attributes, true).times(2).returns({})
+    @factory.create!(2, :minimal, attributes)
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning associating records" do
+  before do
+    @factory = Fakutori(Member)
+    @record = @factory.create_one
+  end
+  
+  it "should return the association builder method if it exists for the given model" do
+    @factory.send(:association_builder_for, Article).should == :associate_to_article
+    @factory.send(:association_builder_for, Article.new).should == :associate_to_article
+    
+    @factory.send(:association_builder_for, Namespaced::Article).should == :associate_to_namespaced_article
+    @factory.send(:association_builder_for, Namespaced::Article.new).should == :associate_to_namespaced_article
+  end
+  
+  it "should return nil if no association builder method can be found for the given model" do
+    @factory.send(:association_builder_for, Unrelated).should == nil
+    @factory.send(:association_builder_for, Unrelated.new).should == nil
+  end
+  
+  it "should call a builder method if it exists for the given model class" do
+    options = {}
+    @factory.expects(:associate_to_article).with(@record, Article, options)
+    @factory.associate(@record, Article, options).should.be @record
+  end
+  
+  it "should call a builder method for each member of a collection" do
+    options = {}
+    collection = @factory.create(2)
+    
+    @factory.expects(:associate_to_article).with(collection.first, Article, options)
+    @factory.expects(:associate_to_article).with(collection.last, Article, options)
+    @factory.associate(collection, Article, options).should.be collection
+  end
+  
+  it "should raise an NoMethodError if an association builder method doesn't exist for a given model" do
+    lambda {
+      @factory.associate(@record, Unrelated, {})
+    }.should.raise NoMethodError
+  end
+  
+  it "should only forward the options hash if it's given by the user" do
+    @factory.expects(:associate_to_article).with(@record, Article)
+    @factory.associate(@record, Article)
+  end
+end
+
+describe "FakutoriSan::Collection, concerning associating records" do
+  before do
+    @factory = Fakutori(Member)
+    @collection = @factory.create!(2)
+  end
+  
+  it "should call #associate on each member and forward the given model and arguments" do
+    options = { 'name' => 'Eloy' }
+    @factory.expects(:associate).with(@collection, Article, options)
+    @collection.associate_to(Article, options)
+  end
+  
+  it "should return itself after associating so the user can chain calls" do
+    @collection.associate_to(Article, {}).should.be @collection
+  end
+  
+  it "should forward the options as `nil' by default" do
+    @factory.expects(:associate).with(@collection, Article, nil)
+    @collection.associate_to(Article)
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `scenes'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  it "should invoke a scene method if it exists and return self" do
+    instance = @factory.create_one
+    @factory.scene(:with_name, instance, :name => 'Alloy').should == instance
+    instance.name.should == 'Alloy'
+  end
+  
+  it "should invoke a scene method for each record in a collection, assign the index to the options, and return self" do
+    collection = @factory.create!(2)
+    @factory.scene(:with_name, collection, :name => 'Alloy').should == collection
+    collection.each_with_index do |record, index|
+      record.reload.name.should == "Alloy#{index}"
+    end
+  end
+  
+  it "should raise a NoMethodError if a requested scene does not exist" do
+    lambda {
+      @factory.scene(:does_not_exist, @factory.build_one)
+    }.should.raise NoMethodError
+  end
+end
+
+describe "FakutoriSan::Collection, concerning `scenes'" do
+  before do
+    @factory = Fakutori(Member)
+    @collection = @factory.create!(2)
+  end
+  
+  it "should call Fakutori#scene with the given scene name, itself, and options" do
+    @collection.apply_scene(:with_name, :name => 'Alloy')
+    @collection.each do |record|
+      record.reload.name.should.match /^Alloy/
+    end
+  end
+end
+
+describe "FakutoriSan::FakutoriExt" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  it "should call Fakutori#associate with the record and options given and return itself" do
+    instance = @factory.create_one
+    
+    @factory.expects(:associate).with(instance, Article, nil)
+    instance.associate_to(Article).should.be instance
+    
+    options = {}
+    @factory.expects(:associate).with(instance, Article, options)
+    instance.associate_to(Article, options).should.be instance
+  end
+  
+  it "should call Fakutori#scene with the record and options given" do
+    instance = @factory.create_one
+    instance.apply_scene(:with_name).reload.name.should == ''
+    instance.apply_scene(:with_name, :name => 'Alloy').reload.name.should == 'Alloy'
+  end
+end

data/test/fakutori_san_scenarios_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../test_helper', __FILE__)
+
+[:uncached, :cached].each do |c|
+  describe "FakutoriSan scenarios, when #{c.to_s}" do
+    # before(:all) do
+    #   p 'here'
+    #   Member.delete_all
+    #   @merel = Member.create!(:name => 'Merel')
+    # end
+    
+    Fakutori.scenario(self, 'Manfred and Eloy') do
+      @manfred = Fakutori(Member).create(:name => 'Manfred')
+      @eloy    = Fakutori(Member).create(:name => 'Eloy')
+      @thijs   = Fakutori(Member).build(:name => 'Thijs')
+      @count   = 3
+    end
+    
+    # it "should define instance variables created in the scenario" do
+    #   @count.should == 3
+    #   @thijs.name.should == 'Thijs'
+    # end
+    # 
+    # it "should find all records created" do
+    #   Member.find_by_name('Manfred').should == @manfred
+    #   Member.find_by_name('Eloy').should == @eloy
+    #   Member.find_by_name('Thijs').should.be.nil
+    #   Member.find_by_name('Merel').should.not.be.nil
+    # end
+    
+    it "should have" do
+      p Member.all.map(&:name)
+      Member.find_by_name('Manfred').should.not.be.nil
+    end
+    
+    it "should have 2" do
+      p Member.all.map(&:name)
+      Member.find_by_name('Manfred').should.not.be.nil
+    end
+  end
+end
+
+# describe "FakutoriSan::Scenario" do
+#   before do
+#     @scenario_1 = FakutoriSan::Scenario.new(__FILE__, self, "scenario 1") { @a = 1 }
+#     @scenario_2 = FakutoriSan::Scenario.new(__FILE__, self, "scenario 2") { @b = 2 }
+#   end
+#   
+#   it "should return a hash specific to the scenario" do
+#     @scenario_1.hash.should == @scenario_1.hash
+#     @scenario_1.hash.should.not == @scenario_2.hash
+#   end
+#   
+#   it "should return a dump directory specific for the scenario" do
+#     @scenario_1.dump_dir.should == @scenario_1.dump_dir
+#     @scenario_1.dump_dir.should.not == @scenario_2.dump_dir
+#   end
+#   
+#   it "should know the tables to cache" do
+#     @scenario_1.tables.sort.should == %w(members articles).sort
+#   end
+# end

data/test/fakutori_san_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "FakutoriSan" do
+  it "should define a method on kernel to create factories" do
+    fakutori = Fakutori(Member)
+    fakutori.model.should == Member
+  end
+end

data/test/models/article.rb

@@ -0,0 +1,2 @@
+class Article < ActiveRecord::Base
+end

data/test/models/member.rb

@@ -0,0 +1,3 @@
+class Member < ActiveRecord::Base
+  validates_presence_of :name
+end

data/test/models/namespaced/article.rb

@@ -0,0 +1,4 @@
+module Namespaced
+  class Article
+  end
+end

data/test/models/unrelated.rb

@@ -0,0 +1,2 @@
+class Unrelated
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+TEST_ROOT_DIR = File.expand_path('..', __FILE__)
+require 'test/unit'
+
+frameworks = {
+  'activesupport' => %w(active_support),
+  'activerecord'  => %w(active_record),
+  'actionpack'    => %w(action_controller)
+}
+
+rails = [
+  File.expand_path('../../../rails', TEST_ROOT_DIR),
+  File.expand_path('../../rails', TEST_ROOT_DIR)
+].detect do |possible_rails|
+  begin
+    entries = Dir.entries(possible_rails)
+    frameworks.keys.all? { |framework| entries.include?(framework) }
+  rescue Errno::ENOENT
+    false
+  end
+end
+frameworks.keys.each { |framework| $:.unshift(File.join(rails, framework, 'lib')) }
+
+$:.unshift File.join(TEST_ROOT_DIR, '/../lib')
+$:.unshift File.join(TEST_ROOT_DIR, '/lib')
+$:.unshift TEST_ROOT_DIR
+
+ENV['RAILS_ENV'] = 'test'
+
+# Require Rails components
+frameworks.values.flatten.each { |lib| require lib }
+require File.expand_path('../../rails/init', __FILE__)
+
+# Libraries for testing
+require 'rubygems' rescue LoadError
+require 'test/spec'
+require 'mocha'
+
+# Open a connection for ActiveRecord
+ActiveRecord::Base.establish_connection(:adapter => "mysql", :database => "fakutori_san_test")
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :members, :force => true do |t|
+    t.string :name
+    t.string :email
+    t.string :password
+  end
+  
+  create_table :articles, :force => true do |t|
+  end
+end
+
+# Require all models and factories used in the tests
+Dir.glob(File.join(TEST_ROOT_DIR, 'models', '**', '*.rb')).each do |model|
+  require model
+end
+
+Dir.glob(File.join(TEST_ROOT_DIR, 'factories', '**', '*.rb')).each do |factory|
+  require factory
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: fakutori-san
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-01 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- TODO
+files: 
+- .gitignore
+- .kick
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION.yml
+- examples/simple_factory.rb
+- fakutori-san.gemspec
+- lib/fakutori_san.rb
+- lib/fakutori_san/fakutori.rb
+- rails/init.rb
+- test/factories/foo_fakutori.rb
+- test/factories/member_fakutori.rb
+- test/fakutori_san_fakutori_test.rb
+- test/fakutori_san_test.rb
+- test/models/article.rb
+- test/models/member.rb
+- test/models/namespaced/article.rb
+- test/models/unrelated.rb
+- test/test_helper.rb
+- test/fakutori_san_scenarios_test.rb
+has_rdoc: true
+homepage: http://github.com/Fingertips/fakutori-san
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.
+test_files: 
+- test/factories/foo_fakutori.rb
+- test/factories/member_fakutori.rb
+- test/fakutori_san_fakutori_test.rb
+- test/fakutori_san_scenarios_test.rb
+- test/fakutori_san_test.rb
+- test/models/article.rb
+- test/models/member.rb
+- test/models/namespaced/article.rb
+- test/models/unrelated.rb
+- test/test_helper.rb
+- examples/simple_factory.rb