factory_boy 1.0.5 → 2.0.0

data/test/db/migrate/20101230223546_create_users.rb.rb

@@ -0,0 +1,14 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.integer :age
+      t.boolean :male
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/test/db/migrate/20101230223547_create_profiles.rb

@@ -0,0 +1,15 @@
+class CreateProfiles < ActiveRecord::Migration
+  def self.up
+    create_table :profiles do |t|
+      t.references :user
+      t.string :password
+      t.boolean :checked
+      t.decimal :height
+      t.float :salary
+    end
+  end
+
+  def self.down
+    drop_table :profiles
+  end
+end

data/test/db/migrate/20101230223548_create_customers.rb

@@ -0,0 +1,11 @@
+class CreateCustomers< ActiveRecord::Migration
+  def self.up
+    create_table :customers do |t|
+      t.string :name
+    end
+  end
+
+  def self.down
+    drop_table :customers
+  end
+end

data/test/db/migrate/20101230223549_create_addresses.rb

@@ -0,0 +1,13 @@
+class CreateAddresses< ActiveRecord::Migration
+  def self.up
+    create_table :addresses do |t|
+      t.references :user
+      t.string :street
+      t.integer :number
+    end
+  end
+
+  def self.down
+    drop_table :addresses
+  end
+end

data/test/db/schema.rb

@@ -0,0 +1,41 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20101230223549) do
+
+  create_table "addresses", :force => true do |t|
+    t.integer "user_id"
+    t.string  "street"
+    t.integer "number"
+  end
+
+  create_table "customers", :force => true do |t|
+    t.string "name"
+  end
+
+  create_table "profiles", :force => true do |t|
+    t.integer "user_id"
+    t.string  "password"
+    t.boolean "checked"
+    t.decimal "height"
+    t.float   "salary"
+  end
+
+  create_table "users", :force => true do |t|
+    t.string   "name"
+    t.integer  "age"
+    t.boolean  "male"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/test/help_test.rb

@@ -2,9 +2,19 @@ Object.const_set("RAILS_ROOT", File.join(File.dirname(__FILE__), '../') )
 
 require 'rubygems'
 require 'test/unit'
-require 'models/adress'
-require 'models/user'
-require 'models/profile'
-require 'models/customer'
+gem 'activerecord', version='3.0.1'
+require 'active_record'
 
-require 'mocha'
+require 'app/models/address'
+require 'app/models/user'
+require 'app/models/profile'
+require 'app/models/customer'
+
+require 'plant'
+
+require 'mocha'
+
+ActiveRecord::Base.establish_connection(
+    :adapter => "sqlite3",
+    :database  => File.join(File.dirname(__FILE__), "db/test.sqlite3")
+)

data/test/plants.rb

@@ -6,16 +6,16 @@ Plant.define :profile do |profile|
   profile.password = "BREIZH!"
 end
 
-Plant.define :adress do |adress|
-  adress.number = 17
-  adress.street = "rue royale"
+Plant.define :address do |address|
+  address.number = 17
+  address.street = "rue royale"
 end
 
 Plant.define :user do |user|
   user.name  = "Zorro"
   user.age = 800
-  user.profile = Plant.association(:profile)
-  user.adresses = [Plant.association(:adress)]
+  user.profile = Plant(:profile)
+  user.addresses = [Plant(:address)]
 end
 
 Plant.define :customer do |customer|

data/test/test_basic_queries.rb

@@ -0,0 +1,36 @@
+require 'help_test'
+
+class TestBasicQueries < ActiveSupport::TestCase
+  
+  
+  def test_should_stubs_find_whith_option_first_and_with_class_method_first
+    user = Plant(:user)
+    assert_equal user, User.find(:first)
+    assert_equal user, User.first
+  end
+
+  def test_should_stubs_find_whith_option_all_and_with_class_method_last
+    user_1, user_2 = [Plant(:user), Plant(:user)]
+    assert_equal user_2, User.find(:last)
+    assert_equal user_2, User.last
+  end
+  
+  def test_should_stubs_find_whith_option_last_and_with_class_method_all
+    users = [Plant(:user), Plant(:user)]
+    assert_equal users, User.find(:all)
+    assert_equal users, User.all
+  end
+  
+  def test_should_find_by_id
+    user = Plant(:user)
+    
+    assert_equal user, User.find(user.id)
+  end
+  
+  def test_should_find_by_ids
+    user_1, user_2 = [Plant(:user), Plant(:user)]
+    
+    assert_equal [user_1, user_2], User.find(user_1.id, user_2.id)
+  end
+  
+end

data/test/test_plant_definition.rb

@@ -0,0 +1,129 @@
+require 'help_test'
+
+class TestPlantDefinition < ActiveSupport::TestCase
+  
+  def setup
+    assert_plants_are_destroyed_before_each_test
+  end
+  
+  def test_simple_definition_of_plant
+    assert customer = Plant(:customer)
+    assert_nil customer.name
+  end
+  
+  def test_definition_should_assign_attributes_and_values
+    user = Plant(:user)
+    
+    assert_equal "Zorro", user.name
+    assert_equal 800, user.age
+  end
+  
+  def test_mocha_is_not_overidden_with_plant_setup
+    Plant(:customer)
+    Plant.expects(:pool).once
+    Plant(:user)
+  end
+
+  def test_instanciation_of_a_plant_with_hash_for_assigning_attributes_values
+    address = Plant(:address)
+    user = Plant(:user, :name => "Marie", :addresses => [address])
+    
+    assert_equal "Marie", user.name
+    assert_equal address, user.addresses.first
+  end
+
+  def test_definition_with_class_option
+    Plant.define :marie, :class => User do |marie|
+      marie.name = "Marie"
+      marie.addresses = [Plant(:address, :street => "Rue de Brest")]
+    end
+    
+    marie = Plant(:marie)
+    assert_equal "Marie", marie.name
+    assert_equal "Rue de Brest", marie.addresses.first.street
+  end
+
+  def test_plants_are_reloaded_only_when_a_plant_is_instanciated
+    assert_equal 0, Plant.plants.size
+    Plant(:user)
+    assert_equal 4, Plant.plants.size
+  end
+  
+  def test_definition_of_a_plant_with_dependent_attribute
+    Plant.define :user do |user|
+      user.name = "Marie"
+      user.addresses = [Plant(:address, :street => "Rue de #{user.name}")]
+    end
+    
+    assert_equal "Rue de Marie", Plant(:user).addresses.first.street
+  end
+
+  def test_plant_sequences
+    Plant.reload
+    assert_equal "incognito1@kantena.com", Plant.next(:email)
+    assert_equal "incognito2@kantena.com", Plant.next(:email)
+  end
+  
+  def test_should_set_foreign_key_values_for_has_many_associations
+    joe, bob = joe_and_bob[:users]
+    
+    assert_equal joe.id, joe.addresses.first.user_id
+    assert_equal bob.id, bob.addresses.first.user_id
+  end
+  
+  def test_should_set_foreign_key_values_for_has_one_associations
+    joe, bob = joe_and_bob[:users]
+
+    assert_equal joe.id, joe.profile.user_id
+    assert_equal bob.id, bob.profile.user_id
+  end
+  
+  def test_creation_of_two_plants_of_same_class_should_keep_each_object_safe
+    joe, bob = joe_and_bob[:users]
+
+    assert_equal "Joe", joe.name
+    assert_equal "Bob", bob.name
+  end
+  
+  def test_creation_of_two_plants_of_same_class_should_keep_has_one_associations_safe
+    users =  joe_and_bob
+    joe, bob, profile_1, profile_2 = users[:users], users[:profiles]
+
+    assert_equal profile_1, joe.profile
+    assert_equal profile_2, bob.profile
+  end
+  
+  def test_creation_of_two_plants_of_same_class_should_keep_has_many_associations_safe
+    users =  joe_and_bob
+    joe, bob = users[:users]
+    address_1, address_2 = users[:addresses]
+     
+    assert_equal [address_1], joe.addresses
+    assert_equal [address_2], bob.addresses
+  end
+  
+  
+  private
+  
+  def assert_plants_are_destroyed_before_each_test
+    assert_equal({}, Plant.plants)
+    assert_equal({}, Plant.all)
+    assert_equal({}, Plant.send(:class_variable_get, :@@sequences))
+    assert_equal 0, Plant.send(:class_variable_get, :@@id)
+  end
+  
+  def joe_and_bob
+    address_1 = Plant(:address, :street => '40 rue de PenMarch')
+    address_2 = Plant(:address, :street => '25 Bd du Guilvinec')
+
+    profile_1 = Plant(:profile, :password => 'azerty')
+    profile_2 = Plant(:profile, :password => 'qwerty')
+    
+    joe = Plant(:user, :name => 'Joe', :addresses => [address_1], :profile => profile_1)
+    bob = Plant(:user, :name => 'Bob', :addresses => [address_2], :profile => profile_2)
+    
+ 
+    {:users => [joe, bob], :addresses => [address_1, address_2], :profiles => [profile_1, profile_2]}
+  end
+  
+end

data/test/test_plants_ids.rb

@@ -0,0 +1,16 @@
+require 'help_test'
+
+class TestPlantsIds < ActiveSupport::TestCase
+
+  def test_each_plant_should_have_unique_id
+    ids = []
+    1.upto(10) do |n|
+      user = Plant(:user)
+      profile = Plant(:profile)
+      address = Plant(:address)
+      ids += [user.id, profile.id, address.id]
+    end
+    assert_equal ids, ids.uniq
+  end
+  
+end

data/test/test_queries_on_has_many_association.rb

@@ -0,0 +1,51 @@
+require 'help_test'
+
+class TestQueriesOnHasManyAssociation < ActiveSupport::TestCase
+  
+  def test_queries_with_conditions_on_has_many_association_with_equality_operator
+    addresses = [Plant(:address, :street => '21 Jump Street'), Plant(:address, :street => 'Rue des Lilas')]
+    joe = Plant(:user, :name => 'Joe', :age => 30, :addresses => addresses)
+    
+    assert_equal([joe], User.where(:name => 'Joe').where("addresses.street = '21 Jump Street'").joins(:addresses))
+    assert_equal([], User.where(:name => 'Joe').where("addresses.street = '20 Jump Street'").joins(:addresses))
+    assert_equal([joe], User.where("addresses.street = '21 Jump Street'").joins(:addresses))
+  end
+  
+  def test_queries_with_conditions_on_has_many_association_with_non_equality_operator
+    addresses = [Plant(:address, :street => '21 Jump Street'), Plant(:address, :street => 'Rue des Lilas')]
+    joe = Plant(:user, :name => 'Joe', :age => 30, :addresses => addresses)
+    
+    assert_equal([], User.where("addresses.street != '21 Jump Street'").joins(:addresses))
+    assert_equal([joe], User.where("addresses.street <> '20 Jump Street'").joins(:addresses))
+  end
+  
+  def test_queries_with_conditions_on_has_many_association_with_inequality_operators
+    addresses = [Plant(:address, :street => 'a'), Plant(:address, :street => 'b')]
+    joe = Plant(:user, :name => 'Joe', :age => 30, :addresses => addresses)
+    
+    assert_equal([], User.where("addresses.street > 'b' ").joins(:addresses))
+    assert_equal([], User.where("addresses.street < 'a' ").joins(:addresses))
+    assert_equal([joe], User.where("addresses.street <= 'b' ").joins(:addresses))
+    assert_equal([joe], User.where("addresses.street >= 'b' ").joins(:addresses))
+    
+  end
+
+  def test_queries_with_conditions_on_has_many_association_with_like_predicate
+    joe = Plant(:user, :name => 'Joe', :addresses => [Plant(:address, :street => 'azb')])
+    bob = Plant(:user, :name => 'Bob', :addresses => [Plant(:address, :street => 'azc')])
+   
+    assert_equal([joe, bob], User.where("addresses.street like  ?", 'az%').joins(:addresses))
+    assert_equal([joe], User.where("addresses.street like  ?", 'azb').joins(:addresses))
+    
+  end
+  
+  def test_queries_on_association_proxy
+    address_1, address_2 = [Plant(:address, :street => '21 Jump Street'), Plant(:address, :street => 'Rue des Lilas')]
+    joe = Plant(:user, :name => 'Joe', :addresses => [address_1, address_2])
+ 
+    assert_equal [address_1], joe.addresses.where(:street => '21 Jump Street') 
+    assert_equal [], joe.addresses.where(:street => '210 Jump Street') 
+  end
+ 
+  
+end

data/test/test_queries_on_has_one_association.rb

@@ -0,0 +1,45 @@
+require 'help_test'
+
+class TestQueriesOnHasOneAssociation < ActiveSupport::TestCase
+  
+  def test_should_stubs_find_with_where_conditions_on_has_one_association
+    profile = Plant(:profile, :password => 'azerty')
+    joe = Plant(:user, :name => 'Joe', :age => 30, :profile => profile)
+   
+    assert_equal [joe], User.where(:name => 'Joe').where("profiles.password = 'azerty'")
+    assert_equal [joe], User.where(:name => 'Joe').where("profiles.password = 'azerty'").joins(:profile)
+    assert_equal [joe], User.where(:name => 'Joe').where("profiles.password = 'azerty'").includes(:profile) 
+  end
+  
+  def test_should_handle_nil_has_one_association
+    joe = Plant(:user, :name => 'Joe', :age => 30, :profile => nil)
+    
+    assert_equal [], User.where(:name => 'Joe').where("profiles.password = 'azerty'")
+  end
+  
+  def test_should_stubs_find_with_where_conditions_on_has_one_association_with_inequality_operators
+    profile = Plant(:profile, :password => 'a')
+    joe = Plant(:user, :name => 'Joe', :profile => profile)
+   
+    assert_equal [joe], User.where(:name => 'Joe').where("profiles.password >= 'a'")
+    assert_equal [], User.where(:name => 'Joe').where("profiles.password > 'a'")
+    assert_equal [], User.where(:name => 'Joe').where("profiles.password < 'a'")
+    assert_equal [], User.where(:name => 'Joe').where("profiles.password != 'a'")
+  end
+  
+  def test_should_stubs_find_with_where_conditions_on_has_one_association_with_boolean_condition
+    profile = Plant(:profile, :checked => false)
+    joe = Plant(:user, :name => 'Joe', :profile => profile)
+   
+    assert_equal [joe], User.where("profiles.checked = '0'")
+  end
+  
+  def test_queries_with_float_and_decimal
+    profile = Plant(:profile, :height => 1.75, :salary => 2000.23)
+    joe = Plant(:user, :name => 'Joe', :profile => profile)
+    
+    assert_equal [joe], User.where('profiles.height = 1.75')
+    assert_equal [joe], User.where('profiles.salary = 2000.23')
+  end
+  
+end

data/test/test_queries_on_model_attributes.rb

@@ -0,0 +1,59 @@
+require 'help_test'
+
+class TestQueriesOnModelAttributes < ActiveSupport::TestCase
+  
+  attr_accessor :joe, :bob
+  
+  def setup
+    @joe = Plant(:user, :name => 'Joe', :age => 30, :male => true)
+    @bob = Plant(:user, :name => 'Bob', :age => 31, :male => true)
+  end
+  
+  def test_stubbed_find_should_return_empty_array_if_none_object_matches_conditions
+    Plant.destroy
+    assert_equal [], User.where(:name => 'Joe')
+  end
+  
+  def test_queries_with_conditions_on_attributes
+    assert_equal [joe], User.where(:name => 'Joe')
+    assert_equal [joe], User.where("users.name = 'Joe'")
+    assert_equal [joe], User.where("name = 'Joe'")
+    assert_equal [joe], User.where(:name => 'Joe', :age => 30)
+    assert_equal [joe], User.where("users.name = 'Joe' or users.age = 30")
+    assert_equal [bob], User.where("name = 'Bob' and age = 31")
+    assert_equal [joe, bob], User.where("age = 30 or age = 31")
+    assert_equal [joe, bob], User.where("(age = 30 and name = 'Joe') or (age = 31 and name = 'Bob')")
+    assert_equal [joe, bob], User.where("age <= 31")
+    assert_equal [], User.where("age > 31")
+    assert_equal [joe], User.where("name = ?", 'Joe')
+  end
+  
+  def test_queries_with_dynamics_finders_methods
+    assert_equal joe, User.find_by_name('Joe')
+  end
+  
+  def test_should_handle_chained_where_clauses
+    assert_equal [joe], User.where(:age => 30).where(:name => 'Joe')
+    users = User.where(:age => 30)
+    assert_equal([joe], users.where(:name => 'Joe'))
+  end
+  
+  def test_queries_with_boolean_conditions
+    assert_equal [joe, bob], User.where(:male => true)
+    assert_equal [], User.where(:male => false)
+    assert_equal [joe, bob], User.where("users.male = '1'")
+    assert_equal [joe, bob], User.where("male = '1'")
+  end
+  
+  def test_queries_with_sql_is_null_and_is_not_null
+    joe.name = nil
+    
+    assert_equal [joe], User.where(:name => nil)
+    assert_equal [joe], User.where('name is null')
+
+    assert_equal [bob], User.where('name is not null')
+  end
+  
+
+  
+end