factory_boy 1.0.5 → 2.0.0

data/README.rdoc

@@ -1,29 +1,64 @@
 == Overview
-Factory_boy aims to avoid slow unit tests due to usage of create/find fixtures in database, with factory_girl for example.
-Factory_boy can be used as factory_girl except that factories are not created in database.
-ActiveRecord::Base find method is stubbed to return fixtures (plants) you have instanciate.
-Differenciate find :all, :first, :last, but doesn't do the work of find with sql conditions.
-Anyway we don't think it's important for unit test, if some find calls with sql conditions, :include ... etc have to be
-tested, report it in integration tests is a better idea.
+Factory Boy aims to avoid slow unit tests due to usage of create/find fixtures in database, with factory_girl for example.
+Factory Boy can be used as factory_girl except that factories are not created in database.
+ActiveRecord::Base finders method is stubbed to return fixtures (plants) you have instanciate.
+
+Now, Factory Boy 2 handle stub of Active Record (3+) queries.
+This means, the fixtures(plants) created with factory boy are retrieved via a AR queries(and only with AR new queries) of your models.
+It does not pretend to stub 100% of all queries, but the coverage can be estimated at about 80%-90% of useful queries.
+
+
+Active Record is stubbed only when at least one Plant is created in a test.
+After each test everything is unstubbed.
+That means, if you have a case where a particular(complex) query is executed but not right stubbed with factory boy you can test using fixtures in databases(with factory girl or just model.create ..), skipping factory boy process.
+
+Tested with Active Record 3.0.1
+Tests are suppose to use ActiveSupport::TestCase
 
 See some examples below.
-You can see also unit tests / code  for deeper comprehension.
+You should see unit tests to inspect tested stubbed queries!
 
-== Install
 
-  gem install factory_boy
+== Queries it supposes to handle
+
+- where clauses on attributes and associations
+- chained where clauses
+- like sql predicate
+- limit, offset
+- order (with only one order clause)
+- ranges (ie where(:age => (20..30)))
+- IS NULL and IS NOT NULL sql predicates
+
+The better way to see queries handled is to see all unit tests.
+
+== Queries NOT handled
+
+- Queries with explicit sql string(find_by_sql("..."))
+- #order with more than one order clause (ie .order(name asc, age desc))
+- IS and IS NOT with other operand than NULL
+
+== Ids
 
+Each plant fixture has now an (unique) id.
 
-== Basic Usage
+== Usage
 
-Define your Plants (=~ Factories if factory_girl) in test/plants.rb
+Define your Plants (~ Factories if factory_girl) in test/plants.rb
 
 Example :
 
+  Plant.define :address do |address|
+    address.number = 12
+    address.street = "rue de Brest"
+  end
+
   Plant.define :user do |user|
    user.name="Bart"
    user.age=800
+   user.addresses = [Plant(:address)]
   end
+  
+  
 
 Get it with : 
 
@@ -34,10 +69,16 @@ Get it with :
 
 
   def test___1
-    user = Plant(:user)
+    address = Plant(:address, :street => 'rue des Lilas')
+    user = Plant(:user, :name => 'Joe', :addresses => [address])
+    
     assert_equal user, User.find #OK
     assert_equal user, User.find(:first) #OK
     assert_equal user, User.find(:last) #OK
+    assert_equal [user], User.where(:name => 'Joe') #OK
+    assert_equal [user], User.where("name = 'Joe' and addresses.street = 'rue des Lilas'").joins(':addresses) #OK
+    assert_equal [address], user.addresses.where(:street => 'rue des Lilas') #OK
+    
   end
 
 
@@ -51,6 +92,7 @@ Get it with :
 
   user = Plant(:user, :name => "Marie", :age => age)
 
+
 == Specification of  the class of the fixture definition 
 
   Plant.define :admin, :class => User do |user|
@@ -66,16 +108,16 @@ Assign fixtures to association in definition of plant :
     profile.password = "BREIZH!"
   end
 
-  Plant.define :adress do |adress|
-    adress.number = 12
-    adress.street = "rue de Brest"
+  Plant.define :address do |address|
+    address.number = 12
+    address.street = "rue de Brest"
   end
 
   Plant.define :user do |user|
     user.name  = "Bart"
     user.age = 800
-    user.profile = Plant.association(:profile)
-    user.adresses = [Plant.association(:adress)]
+    user.profile = Plant(:profile)
+    user.adresses = [Plant(:address)]
   end
 
 
@@ -86,7 +128,7 @@ If you want to use the value of another attribute in definition, do like that :
 
   Plant.define :user do |user|
     user.name = "Marie"
-    user.adresses = [Adress.new(:street => "Rue de #{user.name}")]
+    user.adresses = [Plant(:address, :street => "Rue de #{user.name}")]
   end
 
 
@@ -102,26 +144,21 @@ As with factory_girl you are able to use sequences, like that :
   Plant.next(:email) # => "incognito2@kantena.com"
 
 
-== Dependencies 
-
-No dependency.
-Doesn't work, for now, with Active Support 3.0 (In development)
 
 == In Development 
 
-- Stubs only find of Plant class so we can use both AR find on klasses that are not 'planted'
-- Plant(:xx).clear
-- Provide an id to each Plant
-- When assign instance to an association(ie profile of user), set foreign_key id (ie profile_id of user) 
-- To work with Rails 3 (Active Support 3)
+- Stubs aggregations methods in queries(sum, count ...)
 
-== Change Log
 
-FIX : Push new object in pool of a class doesn't override objects in pool. Safe push.
-FIX : Use #clone instead of #dup. Not same behavior with and without rails(may be overriden by active support)
+== Install
+
+  gem install factory_boy
+
+
+== Change Log
 
-== Notes
 
 
+== Issues
 
 <b>Report Bugs here , on github</b>

data/lib/blank_slate.rb

@@ -0,0 +1,3 @@
+class BlankSlate
+  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+end

data/lib/plant.rb

@@ -1,7 +1,8 @@
-require 'rubygems'
-require 'active_support/inflector'
 require 'stubber'
+require 'selector'
 require 'setup'
+require 'query'
+require 'reflection'
 
 module Plant
 
@@ -9,83 +10,73 @@ module Plant
   @@pool = {}
   @@map = {}
   @@sequences = {}
-  @@stubbed = []
-  
+ @@id = 0
+
   def self.define symbol, args={}
     klass = args[:class] || symbol.to_s.camelize.constantize
-    instance = klass.new
-    yield instance if block_given?
-    add_plant(klass, instance)
-    add_plant(symbol, instance) if args[:class]
-    stubs(instance.class)
-  end
-  
-  def self.stubs klass
-    unless @@stubbed.include?(klass)
-      Plant::Stubber.stubs_find(klass)
-      @@stubbed << klass
-    end
+    definition = klass.new
+    yield definition if block_given?
+    add_plant(klass, definition)
+    add_plant(symbol, definition) if args[:class]
+    Plant::Reflection.reflect(klass)
+    Plant::Stubber.stubs
   end
-  
-  def self.unstub_find_for_each_class
-    @@stubbed.each {|klass| Plant::Stubber.unstubs_find_for(klass)}
-    @@stubbed = []
-  end
-  
-  def self.all
-    @@pool
-  end
-  
+
   def self.add_plant klass, instance
     @@plants[klass] = instance
   end
-  
+
   def self.plants
     @@plants
   end
   
-  def self.reload 
+  def self.all
+    @@pool
+  end
+
+  def self.reload
     load "#{RAILS_ROOT}/test/plants.rb" if Plant.plants.empty?
   end
-  
+
   def self.pool symbol
-    instance = plants[symbol] || plants[symbol.to_s.camelize.constantize]
-    object = instance.clone
+    definition = plants[symbol] || plants[symbol.to_s.camelize.constantize]
+    object = Plant::Reflection.clone(definition,@@id += 1)
     yield  object if block_given?
-    @@pool[instance.class] ||= []  
-    @@pool[instance.class] << object
+    @@pool[definition.class] ||= []
+    @@pool[definition.class] << object
     object
   end
-  
+
   def self.destroy
     @@pool = {}
     @@plants = {}
     @@map = {}
     @@sequences = {}
-    @@stubbed = []
+   @@id = 0
   end
-  
+
   def self.sequence symbol, &proc
     @@sequences[symbol] = {:lambda => proc, :index => 0}
   end
-  
+
   def self.next symbol
     @@sequences[symbol][:lambda].call(@@sequences[symbol][:index] += 1)
   end
   
-  def self.association symbol
-    Plant.pool(symbol)
+  def self.set_foreign_keys object, association, value
+    fk_setter = lambda {|value| value.send(Plant::Reflection.foreign_key(object, association) + '=', object.id)}
+    
+    case
+    when Plant::Reflection.has_many_association?(object.class, association) then value.each {|v| fk_setter.call(v)}
+    when value && Plant::Reflection.has_one_association?(object.class, association) then fk_setter.call(value)
+    end
   end
- 
+
 end
 
 def Plant symbol, args={}
-  Plant.reload 
+  Plant.reload
   Plant.pool(symbol) do |instance|
-    args.each {|key, value| instance.send(key.to_s + '=', value)}
+    args.each {|key, value| Plant.set_foreign_keys(instance, key, value); instance.send(key.to_s + '=', value)}
   end
 end
-
-
-
-

data/lib/query.rb

@@ -0,0 +1,44 @@
+module Plant
+  module Query
+
+    @@wheres = nil
+
+    def self.wheres= wheres
+      @@wheres = wheres
+    end
+
+    def self.wheres
+      @@wheres
+    end
+
+    def self.find_all klass
+      Plant.all[klass] || []
+    end
+
+    def self.find_by_ids klass, ids
+      plants = Plant.all[klass].select{|plant| ids.include?(plant.id)}
+      return plants.first if plants.size == 1
+      plants
+    end
+
+    def self.select klass
+      Plant::Selector.new(:klass => klass, :wheres => @@wheres, :plants => Plant.all[klass].to_a).select
+    end
+
+    def self.order objects, args
+      attribute, order = args.split(" ")
+      objects.sort {|x, y| (x,y = y,x if order == 'desc'); x.send(attribute.to_sym) <=> y.send(attribute.to_sym)}
+    end
+
+    def self.limit objects, limit_value
+      @@objects = objects
+      @@limit = limit_value
+      objects.first(limit_value)
+    end
+    
+    def self.offset objects, offset_value
+      @@objects[offset_value..-1].first(@@limit)
+    end
+
+  end
+end

data/lib/reflection.rb

@@ -0,0 +1,40 @@
+module Plant
+  module Reflection
+    @@reflections = {}
+    
+    def self.reflect klass
+      return if @@reflections[klass]
+      associations = lambda {|klass, macro| klass.reflect_on_all_associations(macro).map{|association| association.name} || []}
+
+      reflection = @@reflections[klass] = Hash.new
+      [:has_many, :has_one, :belongs_to].each {|relation| reflection[relation] = associations.call(klass, relation)}
+      reflection[:attributes] = klass.new.attributes
+    end
+    
+    def self.clone object, id
+      clone = object.class.new
+      cloner = Proc.new {|attribute| clone.send(attribute.to_s + "=", object.send(attribute))}
+      reflection = @@reflections[object.class]
+      
+      clone.id = id
+      reflection[:attributes].keys.each(&cloner)
+      [:has_many, :has_one, :belongs_to].each {|relation| reflection[relation].each(&cloner)}
+
+      clone
+    end
+    
+    def self.has_many_association? klass, method
+      @@reflections[klass][:has_many].include?(method)
+    end
+
+    def self.has_one_association? klass, method
+      @@reflections[klass][:has_one].include?(method)
+      
+    end
+
+    def self.foreign_key object, association
+      object.class.name.underscore + '_id'
+    end
+    
+  end
+end

data/lib/selector.rb

@@ -0,0 +1,181 @@
+require 'blank_slate'
+  
+module Plant
+
+  class Selector
+
+    class Condition
+
+      def initialize wheres, klass
+        @wheres = wheres
+        @klass = klass
+      end
+
+      def to_ruby
+        @wheres.inject("") do |sql, where|
+          copy = where.clone
+          
+          copy.gsub!(/\s=\s/, " == ")
+          copy.gsub!('"','')
+          
+          copy.gsub!(/\s<>\s/, " != ")
+          copy.gsub!('"','')
+          
+          copy.match(/(\sLIKE\s*)'/i)
+          copy.gsub!($1,'.match ') if $1
+          
+          copy.match(/(\sIN\s*)\(/i)
+          copy.gsub!($1,'.included_in?') if $1
+
+          copy.match(/(\sBETWEEN\s*)((\d*)\sAND\s(\d*))/i)
+          between, range = $1, ($3.to_i .. $4.to_i)
+          copy.gsub!($2, '') if $2
+          copy.gsub!(between, ".included_in?(#{range}) ") if between
+          
+          copy.match(/(\sIS\sNULL)/i)
+          copy.gsub!($1,'== nil') if $1
+          
+          copy.match(/(\sIS\sNOT\sNULL)/i)
+          copy.gsub!($1,'!= nil') if $1
+          
+
+          sql << (sql.blank? ? "" : " and ") + copy
+        end
+      end
+    end
+
+    class ArrayCollection < BlankSlate
+
+      def initialize collection
+        @collection = collection
+      end
+
+      def compare operator, operand
+        collection = @collection.dup
+        collection.map{|object| Attribute.new(object, @method)}.any? {|object| object.send(operator, operand) }
+      end
+
+      def method_missing method, *args, &block
+        if (@method)
+          return compare(method, *args)
+        end
+        @method = method
+        self
+      end
+    end
+
+    class Association
+
+      def initialize(association)
+        @association = association
+      end
+
+      def method_missing method, *args, &block
+        return nil unless @association
+        Attribute.new(@association, method)
+      end
+
+    end
+
+    class Attribute
+
+      def initialize reference, method=nil
+        @reference = reference
+        @method = method
+      end
+
+      def compare operator, operand
+        value = @reference.send(@method)
+        operand = type_cast(operand, value)
+        value.send(operator, operand)
+      end
+
+      def type_cast operand, value
+        case value
+        when TrueClass, FalseClass : (operand == 't' || operand == '1')
+        else operand
+        end
+      end
+
+      def == operand
+        compare(:==, operand)
+      end
+
+      def > operand
+        compare(:>, operand)
+      end
+
+      def < operand
+        compare(:<, operand)
+      end
+
+      def >= operand
+        compare(:>=, operand)
+      end
+
+      def <= operand
+        compare(:<=, operand)
+      end
+ 
+      def match operand
+        operand.gsub!(/\%/,'(.*)')
+        operand = '^' + operand + '$'
+        @reference.send(@method).match(operand)
+      end
+      
+      def included_in? *operand
+        range = operand.first if operand.first.is_a?(Range)
+        return range.include?(@reference.send(@method)) if range
+        operand.include?(@reference.send(@method))
+      end
+
+      def method_missing method, *args, &block
+        @method = method
+        self
+      end
+
+    end
+
+    def initialize  opt={}
+      @wheres = opt[:wheres]
+      @plants = opt[:plants]
+      @klass = opt[:klass]
+    end
+
+    def select
+      condition = Condition.new(@wheres, @klass)
+
+      Plant::Stubber.stubs_associations_collections
+      Plant::Stubber.stubs_attribute_methods
+      objects = @plants.select {|object| @binding = binding(); eval("#{condition.to_ruby}")}
+      Plant::Stubber.unstubs_associations_collections
+      Plant::Stubber.unstubs_attribute_methods
+
+      objects
+    end
+
+    private
+
+      def method_missing method, *args, &block
+        case
+        when has_one_association?(method) then Association.new(eval("object.#{method.to_s[0..-2]}", @binding))
+        when has_many_association?(method) then ArrayCollection.new(eval("object.#{method}", @binding))
+        when self_reference?(method) then Attribute.new(eval("object", @binding))
+        else Attribute.new(eval("object", @binding), method)
+        end
+      end
+
+      def self_reference? method
+        @klass.name.downcase == method.to_s[0..-2]
+      end
+
+      def has_one_association? method
+        @klass.new.respond_to?(method.to_s[0..-2])
+      end
+
+      def has_many_association? method
+        Plant::Reflection.has_many_association?(@klass, method)
+      end
+
+  end
+end