Making unit tests run more faster

Joenio Costa
1 parent 36ad1dcf
Showing 40 changed files with 369 additions and 390 deletions Show diff stats
test/factories.rb
test/unit/acts_as_filesystem_test.rb
test/unit/acts_as_having_boxes.rb
test/unit/acts_as_having_boxes_test.rb
test/unit/add_friend_test.rb
test/unit/add_member_test.rb
test/unit/application_helper_test.rb
test/unit/approve_article_test.rb
test/unit/article_block_test.rb
test/unit/article_test.rb
test/unit/block_test.rb
test/unit/blog_archives_block_test.rb
test/unit/blog_helper_test.rb
test/unit/blog_test.rb
test/unit/comment_notifier_test.rb
test/unit/communities_block_test.rb
test/unit/community_test.rb
test/unit/contact_test.rb
test/unit/content_viewer_helper_test.rb
test/unit/create_enterprise_test.rb
@@ -220,6 +220,11 @@ module Noosfero::Factory
     { :name => name, :slug => name.to_slug, :path => name.to_slug }
   end
  
+  alias :defaults_for_text_article :defaults_for_article
+  alias :defaults_for_textile_article :defaults_for_article
+  alias :defaults_for_tiny_mce_article :defaults_for_article
+  alias :defaults_for_rss_feed :defaults_for_article
+
   ###############################################
   # Folder
   ###############################################
@@ -249,7 +254,8 @@ module Noosfero::Factory
   # Blog
   ###############################################
   def defaults_for_blog
-    { :name => 'My blog ' + factory_num_seq.to_s }
+    name = 'My blog ' + factory_num_seq.to_s
+    { :name => name, :slug => name.to_slug }
   end
  
   def create_blog
@@ -289,12 +295,11 @@ module Noosfero::Factory
   # Category
   ###############################################
   def defaults_for_category
-    { :environment_id => Environment.default.id, :name => 'category' + factory_num_seq.to_s }
+    name = 'category' + factory_num_seq.to_s
+    { :environment_id => 1, :name => name, :slug => name.to_slug, :path => name.to_slug }
   end
  
-  def defaults_for_region
-    defaults_for_category
-  end
+  alias :defaults_for_region :defaults_for_category
  
   ###############################################
   # Box
@@ -303,4 +308,23 @@ module Noosfero::Factory
     { }
   end
  
+  ###############################################
+  # Block
+  ###############################################
+  def defaults_for_block
+    { }
+  end
+
+  ###############################################
+  # Task
+  ###############################################
+  def defaults_for_task
+    { :code => "task_for_test_#{factory_num_seq.to_s}" }
+  end
+
+  alias :defaults_for_add_friend :defaults_for_task
+  alias :defaults_for_add_member :defaults_for_task
+  alias :defaults_for_create_community :defaults_for_task
+  alias :defaults_for_email_activation :defaults_for_task
+
 end
@@ -75,9 +75,9 @@ class ActsAsFilesystemTest &lt; Test::Unit::TestCase
  
   should 'be able to list text articles that are children of a folder' do
     profile = create_user('testinguser').person
-    folder = Folder.create!(:name => 'folder', :profile => profile)
-    article1 = Article.create(:name => 'article 1', :profile => profile, :parent => folder)
-    article2 = Article.create(:name => 'article 2', :profile => profile, :parent => folder)
+    folder = fast_create(Folder, :name => 'folder', :profile_id => profile.id)
+    article1 = Article.create!(:name => 'article 1', :profile => profile, :parent => folder)
+    article2 = Article.create!(:name => 'article 2', :profile => profile, :parent => folder)
     folder.reload
  
     assert_equal [folder, article1, article2], folder.map_traversal
@@ -1,16 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class ActsAsHavingBoxesTest < Test::Unit::TestCase
-
-  should 'be able to find blocks by id' do
-    env = Environment.create!(:name => 'my test environment')
-    env.boxes.destroy_all
-
-    env.boxes << Box.new
-    block = Block.new
-    env.boxes.first.blocks << block
-
-    assert_equal block, env.blocks.find(block.id)
-  end
-
-end
@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ActsAsHavingBoxesTest < Test::Unit::TestCase
+
+  should 'be able to find blocks by id' do
+    env = fast_create(Environment, :name => 'An environment without blocks')
+
+    env.boxes << Box.new
+    block = Block.new
+    env.boxes.first.blocks << block
+
+    assert_equal block, env.blocks.find(block.id)
+  end
+
+end
@@ -10,7 +10,7 @@ class AddFriendTest &lt; ActiveSupport::TestCase
     p1 = create_user('testuser1').person
     p2 = create_user('testuser2').person
  
-    task = AddFriend.create!(:person => p1, :friend => p2)
+    task = fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id, :target_type => 'Person')
  
     assert_difference Friendship, :count, 2 do
       task.finish
@@ -26,7 +26,10 @@ class AddFriendTest &lt; ActiveSupport::TestCase
     p1 = create_user('testuser1').person
     p2 = create_user('testuser2').person
  
-    task = AddFriend.create!(:person => p1, :group_for_person => 'friend1', :friend => p2, :group_for_friend => 'friend2')
+    task = fast_create(AddFriend, :requestor_id => p1, :target_id => p2.id, :target_type => 'Person')
+    task.group_for_person = 'friend1'
+    task.group_for_friend = 'friend2'
+    assert task.save
  
     assert_difference Friendship, :count, 2 do
       task.finish
@@ -72,7 +75,7 @@ class AddFriendTest &lt; ActiveSupport::TestCase
     p1 = create_user('testuser1').person
     p2 = create_user('testuser2').person
  
-    task = AddFriend.create!(:person => p1, :friend => p2)
+    task = fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id)
  
     assert_equal 'testuser1 wants to be your friend.', task.description
   end
@@ -85,7 +88,7 @@ class AddFriendTest &lt; ActiveSupport::TestCase
   should 'not add friend twice' do
     p1 = create_user('testuser1').person
     p2 = create_user('testuser2').person
-    AddFriend.create!(:person => p1, :friend => p2)
+    fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id)
     assert_raise ActiveRecord::RecordInvalid do
       AddFriend.create!(:person => p1, :friend => p2)
     end
@@ -8,9 +8,10 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'actually add memberships when confirmed' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'closed community', :closed => true)
+    c = fast_create(Community, :name => 'closed community')
+    c.update_attribute(:closed, true)
     TaskMailer.stubs(:deliver_target_notification)
-    task = AddMember.create!(:person => p, :organization => c)
+    task = fast_create(AddMember, :requestor_id => p.id, :target_id => c.id, :target_type => 'Community')
     assert_difference c, :members, [p] do
       task.finish
       c.reload
@@ -41,7 +42,8 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'send e-mails' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'closed community', :closed => true)
+    c = fast_create(Community, :name => 'closed community')
+    c.update_attribute(:closed, true)
  
     TaskMailer.expects(:deliver_target_notification).at_least_once
  
@@ -50,11 +52,12 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'provide proper description' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'closed community', :closed => true)
+    c = fast_create(Community, :name => 'closed community')
+    c.update_attribute(:closed, true)
  
     TaskMailer.stubs(:deliver_target_notification)
  
-    task = AddMember.create!(:person => p, :organization => c)
+    task = fast_create(AddMember, :requestor_id => p.id, :target_id => c.id, :target_type => 'Community')
  
     assert_equal 'testuser1 wants to be a member of "closed community".', task.description
   end
@@ -66,7 +69,7 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'have roles' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'community_test')
+    c = fast_create(Community, :name => 'community_test')
     TaskMailer.stubs(:deliver_target_notification)
     task = AddMember.create!(:roles => [1,2,3], :person => p, :organization => c)
     assert_equal [1,2,3], task.roles
@@ -74,7 +77,7 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'put member with the right roles' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'community_test')
+    c = fast_create(Community, :name => 'community_test')
  
     roles = [Profile::Roles.member(c.environment.id), Profile::Roles.admin(c.environment.id)]
     TaskMailer.stubs(:deliver_target_notification)
@@ -97,7 +100,7 @@ class AddMemberTest &lt; ActiveSupport::TestCase
  
   should 'ignore roles with id zero' do
     p = create_user('testuser1').person
-    c = Community.create!(:name => 'community_test')
+    c = fast_create(Community, :name => 'community_test')
  
     role = Profile::Roles.member(c.environment.id)
     TaskMailer.stubs(:deliver_target_notification)
@@ -98,36 +98,11 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
  
   should 'rolename for' do
     person = create_user('usertest').person
-    community = Community.create!(:name => 'new community', :identifier => 'new-community', :environment => Environment.default)
+    community = fast_create(Community, :name => 'new community', :identifier => 'new-community', :environment_id => Environment.default.id)
     community.add_member(person)
     assert_equal 'Profile Member', rolename_for(person, community)
   end
  
-  should 'display categories' do
-    # FIXME implement this test!!!
-    assert true
-    #category = Category.create!(:name => 'parent category for testing', :environment_id => Environment.default)
-    #child = Category.create!(:name => 'child category for testing',   :environment => Environment.default, :display_in_menu => true, :parent => category)
-    #owner = create_user('testuser').person
-    #@article = owner.articles.create!(:name => 'ytest')
-    #@article.add_category(category)
-    #expects(:environment).returns(Environment.default)
-    #result = select_categories(:article)
-    #assert_match /parent category/, result
-  end
-
-  should 'not display categories if has no child' do
-    # FIXME implement this test!!!
-    assert true
-    #category = Category.create!(:name => 'parent category for testing', :environment_id => Environment.default)
-    #owner = create_user('testuser').person
-    #@article = owner.articles.create!(:name => 'ytest')
-    #@article.add_category(category)
-    #expects(:environment).returns(Environment.default)
-    #result = select_categories(:article)
-    #assert_no_match /parent category/, result
-  end
-
   should 'get theme from environment by default' do
     @environment = mock
     @environment.stubs(:theme).returns('my-environment-theme')
@@ -229,7 +204,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'return nil if disable_categories is enabled' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
     assert_not_nil env
     env.enable(:disable_categories)
@@ -263,14 +238,14 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'not draw sex icon when disabled in the environment' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     env.expects(:enabled?).with('disable_gender_icon').returns(true)
     stubs(:environment).returns(env)
     assert_equal '', profile_sex_icon(Person.new(:sex => 'male'))
   end
  
   should 'display field on signup' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
  
     controller = mock
@@ -283,7 +258,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'not display field on signup' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
  
     controller = mock
@@ -296,7 +271,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'display active fields' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
  
     controller = mock
@@ -309,7 +284,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'not display active fields' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
  
     controller = mock
@@ -322,7 +297,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'display required fields' do
-    env = Environment.create!(:name => 'env test')
+    env = fast_create(Environment, :name => 'env test')
     stubs(:environment).returns(env)
  
     controller = mock
@@ -380,7 +355,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
  
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(false)
     assert ! ask_to_join?
@@ -393,7 +368,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
  
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(false)
     assert ask_to_join?
@@ -406,7 +381,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
  
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(true)
     p = create_user('test_user').person
@@ -422,7 +397,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e = Environment.default
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(true)
     p = create_user('test_user').person
@@ -438,7 +413,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e = Environment.default
     e.stubs(:enabled?).with(:join_community_popup).returns(false)
     stubs(:environment).returns(e)
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(false)
     assert !ask_to_join?
@@ -450,7 +425,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e = Environment.default
     e.stubs(:enabled?).with(:join_community_popup).returns(false)
     stubs(:environment).returns(e)
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(true)
     p = create_user('test_user').person
@@ -467,7 +442,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
  
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(false)
     stubs(:session).returns({:no_asking => [c.id]})
@@ -482,7 +457,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
     e.stubs(:enabled?).with(:join_community_popup).returns(true)
     stubs(:environment).returns(e)
  
-    c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     stubs(:logged_in?).returns(true)
     stubs(:session).returns({:no_asking => [c.id]})
@@ -507,7 +482,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   should 'display name on page title if profile doesnt have nickname' do
     stubs(:environment).returns(Environment.default)
  
-    c = Community.create(:name => 'Comm name', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'Comm name', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     assert_match(/Comm name/, page_title)
   end
@@ -515,7 +490,7 @@ class ApplicationHelperTest &lt; Test::Unit::TestCase
   should 'display nickname on page title if profile has nickname' do
     stubs(:environment).returns(Environment.default)
  
-    c = Community.create(:name => 'Community for tests', :nickname => 'Community nickname', :identifier => 'test_comm')
+    c = fast_create(Community, :name => 'Community for tests', :nickname => 'Community nickname', :identifier => 'test_comm')
     stubs(:profile).returns(c)
     assert_match(/Community nickname/, page_title)
   end
@@ -11,7 +11,7 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
   attr_reader :profile
  
   should 'have name, reference article and profile' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
  
     a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
  
@@ -21,7 +21,7 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'create published article when finished' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
     a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
  
     assert_difference PublishedArticle, :count do
@@ -39,7 +39,7 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'have parent if defined' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
     folder = profile.articles.create!(:name => 'test folder', :type => 'Folder')
  
     a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile, :article_parent_id => folder.id)
@@ -48,7 +48,7 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'not have parent if not defined' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
  
     a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
  
@@ -75,7 +75,7 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
  
   should 'handle blank names' do
     article = profile.articles.create!(:name => 'test article')
-    community = Community.create!(:name => 'test comm')
+    community = fast_create(Community, :name => 'test comm')
     a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
  
     assert_difference PublishedArticle, :count do
@@ -84,14 +84,14 @@ class ApproveArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'notify target if group is moderated' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
     community = Community.create!(:name => 'test comm', :moderated_articles => true)
     a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
     assert !ActionMailer::Base.deliveries.empty?
   end
  
   should 'not notify target if group is not moderated' do
-    article = profile.articles.create!(:name => 'test article')
+    article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
     community = Community.create!(:name => 'test comm', :moderated_articles => false)
     a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
     assert ActionMailer::Base.deliveries.empty?
@@ -71,7 +71,7 @@ class ArticleBlockTest &lt; Test::Unit::TestCase
     env.articles.destroy_all
     assert_equal [], env.articles
     community = fast_create(Community)
-    a = community.articles.create!(:name => 'test')
+    a = fast_create(TextArticle, :profile_id => community.id, :name => 'test')
     env.portal_community=community
     env.save
     block = ArticleBlock.create(:article => a)
@@ -76,7 +76,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'provide HTML version' do
     profile = create_user('testinguser').person
-    a = Article.create!(:name => 'my article', :profile_id => profile.id)
+    a = fast_create(Article, :name => 'my article', :profile_id => profile.id)
     a.expects(:body).returns('the body of the article')
     assert_equal 'the body of the article', a.to_html
   end
@@ -88,7 +88,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'provide first paragraph of HTML version' do
     profile = create_user('testinguser').person
-    a = Article.create!(:name => 'my article', :profile_id => profile.id)
+    a = fast_create(Article, :name => 'my article', :profile_id => profile.id)
     a.expects(:body).returns('<p>the first paragraph of the article</p> The second paragraph')
     assert_equal '<p>the first paragraph of the article</p>', a.first_paragraph
   end
@@ -149,11 +149,11 @@ class ArticleTest &lt; Test::Unit::TestCase
  
     Article.destroy_all
  
-    first = profile.articles.build(:name => 'first'); first.save!
-    second = profile.articles.build(:name => 'second'); second.save!
-    third = profile.articles.build(:name => 'third'); third.save!
-    fourth = profile.articles.build(:name => 'fourth'); fourth.save!
-    fifth = profile.articles.build(:name => 'fifth'); fifth.save!
+    first = fast_create(TextArticle, :profile_id => profile.id, :name => 'first')
+    second = fast_create(TextArticle, :profile_id => profile.id, :name => 'second')
+    third = fast_create(TextArticle, :profile_id => profile.id, :name => 'third')
+    fourth = fast_create(TextArticle, :profile_id => profile.id, :name => 'fourth')
+    fifth = fast_create(TextArticle, :profile_id => profile.id, :name => 'fifth')
  
     other_first = other_profile.articles.build(:name => 'first'); other_first.save!
  
@@ -165,8 +165,8 @@ class ArticleTest &lt; Test::Unit::TestCase
     p = create_user('usr1').person
     Article.destroy_all
  
-    first  = p.articles.build(:name => 'first',  :published => true);  first.save!
-    second = p.articles.build(:name => 'second', :published => false); second.save!
+    first  = fast_create(TextArticle, :profile_id => p.id, :name => 'first',  :published => true)
+    second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
  
     assert_equal [ first ], Article.recent(nil)
   end
@@ -175,8 +175,8 @@ class ArticleTest &lt; Test::Unit::TestCase
     p = create_user('usr1').person
     Article.destroy_all
  
-    first  = p.articles.build(:name => 'first',  :published => true);  first.save!
-    second = p.articles.build(:name => 'second', :published => false); second.save!
+    first  = fast_create(TextArticle, :profile_id => p.id, :name => 'first',  :published => true)
+    second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
  
     assert_equal [ first ], Article.recent(nil)
   end
@@ -185,8 +185,8 @@ class ArticleTest &lt; Test::Unit::TestCase
     p = fast_create(Person, :public_profile => false)
     Article.destroy_all
  
-    first  = p.articles.build(:name => 'first',  :published => true);  first.save!
-    second = p.articles.build(:name => 'second', :published => false); second.save!
+    first  = fast_create(TextArticle, :profile_id => p.id, :name => 'first',  :published => true)
+    second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
  
     assert_equal [ ], Article.recent(nil)
   end
@@ -195,8 +195,8 @@ class ArticleTest &lt; Test::Unit::TestCase
     p = fast_create(Person, :visible => false)
     Article.destroy_all
  
-    first  = p.articles.build(:name => 'first',  :published => true);  first.save!
-    second = p.articles.build(:name => 'second', :published => false); second.save!
+    first  = fast_create(TextArticle, :profile_id => p.id, :name => 'first',  :published => true)
+    second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
  
     assert_equal [ ], Article.recent(nil)
   end
@@ -224,7 +224,7 @@ class ArticleTest &lt; Test::Unit::TestCase
     Article.destroy_all
  
     first = UploadedFile.new(:profile => p, :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'));  first.save!
-    second = p.articles.build(:name => 'second'); second.save!
+    second = fast_create(TextArticle, :profile_id => p.id, :name => 'second')
  
     assert_equal [ second ], Article.recent(nil)
   end
@@ -232,7 +232,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   should 'not show RssFeed as recent' do
     p = create_user('usr1').person
     Article.destroy_all
-    first = RssFeed.create!(:profile => p, :name => 'my feed', :advertise => true)
+    first = fast_create(RssFeed, :profile_id => p.id, :name => 'my feed', :advertise => true)
     first.limit = 10; first.save!
     second = p.articles.build(:name => 'second'); second.save!
  
@@ -242,7 +242,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   should 'not show blog as recent' do
     p = create_user('usr1').person
     Article.destroy_all
-    first = Blog.create!(:profile => p, :name => 'my blog', :advertise => true)
+    first = fast_create(Blog, :profile_id => p.id, :name => 'my blog', :advertise => true)
     second = p.articles.build(:name => 'second'); second.save!
  
     assert_equal [ second ], Article.recent(nil)
@@ -425,8 +425,8 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'be able to create an article already with categories' do
-    c1 = Category.create!(:environment => Environment.default, :name => 'c1')
-    c2 = Category.create!(:environment => Environment.default, :name => 'c2')
+    c1 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c1')
+    c2 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c2')
  
     p = create_user('testinguser').person
     a = p.articles.create!(:name => 'test', :category_ids => [c1.id, c2.id])
@@ -435,7 +435,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'not add a category twice to article' do
-    c1 = Category.create!(:environment => Environment.default, :name => 'c1')
+    c1 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c1')
     c2 = c1.children.create!(:environment => Environment.default, :name => 'c2')
     c3 = c1.children.create!(:environment => Environment.default, :name => 'c3')
     owner = create_user('testuser').person
@@ -454,23 +454,23 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'say that logged off user cannot see private article' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    article = Article.create!(:name => 'test article', :profile => profile, :published => false)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
  
     assert !article.display_to?(nil)
   end 
  
   should 'say that not member of profile cannot see private article' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    article = Article.create!(:name => 'test article', :profile => profile, :published => false)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
     person = create_user('test_user').person
  
     assert !article.display_to?(person)
   end
  
   should 'say that member user can not see private article' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    article = Article.create!(:name => 'test article', :profile => profile, :published => false)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
     person = create_user('test_user').person
     profile.affiliate(person, Profile::Roles.member(profile.environment.id))
  
@@ -478,8 +478,8 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'say that profile admin can see private article' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    article = Article.create!(:name => 'test article', :profile => profile, :published => false)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
     person = create_user('test_user').person
     profile.affiliate(person, Profile::Roles.admin(profile.environment.id))
  
@@ -487,8 +487,8 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'say that profile moderator can see private article' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    article = Article.create!(:name => 'test article', :profile => profile, :published => false)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
     person = create_user('test_user').person
     profile.affiliate(person, Profile::Roles.moderator(profile.environment.id))
  
@@ -496,8 +496,8 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'not show article to non member if article public but profile private' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile', :public_profile => false)
-    article = Article.create!(:name => 'test article', :profile => profile, :published => true)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile', :public_profile => false)
+    article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => true)
     person1 = create_user('test_user1').person
     profile.affiliate(person1, Profile::Roles.member(profile.environment.id))
     person2 = create_user('test_user2').person
@@ -508,17 +508,17 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'make new article private if created inside a private folder' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    folder = Folder.create!(:name => 'my_intranet', :profile => profile, :published => false)
-    article = Article.create!(:name => 'my private article', :profile => profile, :parent => folder)
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    folder = fast_create(Folder, :name => 'my_intranet', :profile_id => profile.id, :published => false)
+    article = fast_create(Article, :name => 'my private article', :profile_id => profile.id, :parent_id => folder.id)
  
     assert !article.published?
   end
  
   should 'save as private' do
-    profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
-    folder = Folder.create!(:name => 'my_intranet', :profile => profile, :published => false)
-    article = TextileArticle.new(:name => 'my private article')
+    profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
+    folder = fast_create(Folder, :name => 'my_intranet', :profile_id => profile.id, :published => false)
+    article = fast_create(Article, :name => 'my private article')
     article.profile = profile
     article.parent = folder
     article.save!
@@ -540,7 +540,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'display private articles to people who can view private content' do
     person = create_user('test_user').person
-    article = Article.create!(:name => 'test article', :profile => person, :published => false)
+    article = fast_create(Article, :name => 'test article', :profile_id => person.id, :published => false)
  
     admin_user = create_user('admin_user').person
     admin_user.stubs(:has_permission?).with('view_private_content', article.profile).returns('true')
@@ -570,7 +570,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'mantain the type in a copy' do
     p = create_user('test_user').person
-    a = Folder.create!(:name => 'test folder', :profile => p)
+    a = fast_create(Folder, :name => 'test folder', :profile_id => p.id)
     b = a.copy(:parent => a, :profile => p)
  
     assert_kind_of Folder, b
@@ -638,15 +638,15 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'identify if belongs to blog' do
     p = create_user('user_blog_test').person
-    blog = Blog.create!(:name => 'Blog test', :profile => p)
-    post = TextileArticle.create!(:name => 'First post', :profile => p, :parent => blog)
+    blog = fast_create(Blog, :name => 'Blog test', :profile_id => p.id)
+    post = fast_create(TextileArticle, :name => 'First post', :profile_id => p.id, :parent_id => blog.id)
     assert post.belongs_to_blog?
   end
  
   should 'not belongs to blog' do
     p = create_user('user_blog_test').person
-    folder = Folder.create!(:name => 'Not Blog', :profile => p)
-    a = TextileArticle.create!(:name => 'Not blog post', :profile => p, :parent => folder)
+    folder = fast_create(Folder, :name => 'Not Blog', :profile_id => p.id)
+    a = fast_create(TextileArticle, :name => 'Not blog post', :profile_id => p.id, :parent_id => folder.id)
     assert !a.belongs_to_blog?
   end
  
@@ -656,7 +656,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'hold hits count' do
-    a = Article.create!(:name => 'Test article', :profile => profile)
+    a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
     a.hits = 10
     a.save!
     a.reload
@@ -664,7 +664,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'increment hit counter when hitted' do
-    a = Article.create!(:name => 'Test article', :profile => profile, :hits => 10)
+    a = fast_create(Article, :name => 'Test article', :profile_id => profile.id, :hits => 10)
     a.hit
     assert_equal 11, a.hits
     a.reload
@@ -672,13 +672,13 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'have display_hits setting with default true' do
-    a = Article.create!(:name => 'Test article', :profile => profile)
+    a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
     assert_respond_to a, :display_hits
     assert_equal true, a.display_hits
   end
  
   should 'can display hits' do
-    a = Article.create!(:name => 'Test article', :profile => profile)
+    a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
     assert_respond_to a, :can_display_hits?
     assert_equal true, a.can_display_hits?
   end
@@ -690,7 +690,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'not return a view url when common article' do
-    a = Article.create!(:name => 'Test article', :profile => profile)
+    a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
  
     assert_equal a.url, a.view_url
   end
@@ -708,17 +708,17 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'published_at is same as created_at if not set' do
-    a = Article.create!(:name => 'Published at', :profile => profile)
+    a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
     assert_equal a.created_at, a.published_at
   end
  
   should 'use npage to compose cache key' do
-    a = Article.create!(:name => 'Published at', :profile => profile)
+    a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
     assert_match(/-npage-2/,a.cache_key(:npage => 2))
   end
  
   should 'use year and month to compose cache key' do
-    a = Article.create!(:name => 'Published at', :profile => profile)
+    a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
     assert_match(/-year-2009-month-04/, a.cache_key(:year => '2009', :month => '04'))
   end
  
@@ -728,7 +728,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'get tagged with tag' do
-    a = Article.create!(:name => 'Published at', :profile => profile, :tag_list => 'bli')
+    a = create(Article, :name => 'Published at', :profile_id => profile.id, :tag_list => 'bli')
     as = Article.find_tagged_with('bli')
  
     assert_includes as, a
@@ -749,7 +749,7 @@ class ArticleTest &lt; Test::Unit::TestCase
  
   should 'ignore category with zero as id' do
     a = profile.articles.create!(:name => 'a test article')
-    c = Category.create!(:name => 'test category', :environment => profile.environment)
+    c = fast_create(Category, :name => 'test category', :environment_id => profile.environment.id)
     a.category_ids = ['0', c.id, nil]
     assert a.save
     assert_equal [c], a.categories
@@ -766,13 +766,13 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'add owner on cache_key when profile is community' do
-    c = Community.create!(:name => 'new_comm')
+    c = fast_create(Community)
     a = c.articles.create!(:name => 'a test article')
     assert_match(/-owner/, a.cache_key({}, c))
   end
  
   should 'have a creator method' do
-    c = Community.create!(:name => 'new_comm')
+    c = fast_create(Community)
     a = c.articles.create!(:name => 'a test article', :last_changed_by => profile)
     p = create_user('other_user').person
     a.update_attributes(:body => 'some content', :last_changed_by => p); a.save!
@@ -780,7 +780,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'allow creator to edit if is publisher' do
-    c = Community.create!(:name => 'new_comm')
+    c = fast_create(Community)
     p = create_user_with_permission('test_user', 'publish_content', c)
     a = c.articles.create!(:name => 'a test article', :last_changed_by => p)
  
@@ -788,7 +788,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'allow user with "Manage content" permissions to edit' do
-    c = Community.create!(:name => 'new_comm')
+    c = fast_create(Community)
     p = create_user_with_permission('test_user', 'post_content', c)
     a = c.articles.create!(:name => 'a test article')
  
@@ -796,7 +796,7 @@ class ArticleTest &lt; Test::Unit::TestCase
   end
  
   should 'update slug from name' do
-    article = Article.create!(:name => 'A test article', :profile => profile)
+    article = create(Article, :name => 'A test article', :profile_id => profile.id)
     assert_equal 'a-test-article', article.slug
     article.name = 'Changed name'
     assert_equal 'changed-name', article.slug
@@ -9,7 +9,7 @@ class BlockTest &lt; Test::Unit::TestCase
   should 'access owner through box' do
     user = create_user('testinguser').person
  
-    box = Box.create!(:owner => user)
+    box = fast_create(Box, :owner_id => user, :owner_type => 'Person')
  
     block = Block.new
     block.box = box
@@ -54,14 +54,14 @@ class BlockTest &lt; Test::Unit::TestCase
   should 'provide chache keys' do
      p = create_user('test_user').person
      box = p.boxes[0]
-     b = Block.create!(:box => box)
+     b = fast_create(Block, :box_id => box.id)
  
      assert_equal( "block-id-#{b.id}", b.cache_keys)
   end
  
   should 'list enabled blocks' do
-    block1 = Block.create!(:title => 'test 1')
-    block2 = Block.create!(:title => 'test 2', :enabled => false)
+    block1 = fast_create(Block, :title => 'test 1')
+    block2 = fast_create(Block, :title => 'test 2', :enabled => false)
     assert_includes Block.enabled, block1
     assert_not_includes Block.enabled, block2
   end
@@ -89,7 +89,7 @@ class BlockTest &lt; Test::Unit::TestCase
   should 'be able to save display setting' do
     user = create_user('testinguser').person
     box = fast_create(Box, :owner_id => user.id)
-    block = Block.create!(:display => 'never', :box => box)
+    block = create(Block, :display => 'never', :box_id => box.id)
     block.reload
     assert_equal 'never', block.display
   end
@@ -97,7 +97,7 @@ class BlockTest &lt; Test::Unit::TestCase
   should 'be able to update display setting' do
     user = create_user('testinguser').person
     box = fast_create(Box, :owner_id => user.id)
-    block = Block.create!(:display => 'never', :box => box)
+    block = create(Block, :display => 'never', :box_id => box.id)
     assert block.update_attributes!(:display => 'always')
     block.reload
     assert_equal 'always', block.display
@@ -21,7 +21,7 @@ class BlogArchivesBlockTest &lt; ActiveSupport::TestCase
     date = DateTime.parse('2008-01-01')
     blog = profile.blog
     for i in 1..10 do
-      post = TextileArticle.create!(:name => "post #{i} test", :profile => profile, :parent => blog)
+      post = fast_create(TextileArticle, :name => "post #{i} test", :profile_id => profile.id, :parent_id => blog.id)
       post.update_attribute(:published_at, date)
     end
     block = BlogArchivesBlock.new
@@ -33,7 +33,7 @@ class BlogArchivesBlockTest &lt; ActiveSupport::TestCase
     date = DateTime.parse('2008-01-01')
     blog = profile.blog
     for i in 1..10 do
-      post = TextileArticle.create!(:name => "post #{i} test", :profile => profile, :parent => blog)
+      post = fast_create(TextileArticle, :name => "post #{i} test", :profile_id => profile.id, :parent_id => blog.id)
       assert post.update_attribute(:published_at, date)
     end
     block = BlogArchivesBlock.new
@@ -44,7 +44,7 @@ class BlogArchivesBlockTest &lt; ActiveSupport::TestCase
   should 'order list of amount posts' do
     blog = profile.blog
     for i in 1..10 do
-      post = TextileArticle.create!(:name => "post #{i} test", :profile => profile, :parent => blog)
+      post = fast_create(TextileArticle, :name => "post #{i} test", :profile_id => profile.id, :parent_id => blog.id)
       post.update_attribute(:published_at, DateTime.parse("2008-#{i}-01"))
     end
     block = BlogArchivesBlock.new
@@ -90,11 +90,11 @@ class BlogArchivesBlockTest &lt; ActiveSupport::TestCase
   end
  
   should 'show posts from first blog' do
-    (blog_one, blog_two) = profile.blogs
     profile.articles << Blog.new(:name => 'Blog Two', :profile => profile)
+    (blog_one, blog_two) = profile.blogs
     for month in 1..3
-      TextileArticle.create!(:name => "blog one - post #{month}", :profile => profile, :parent => blog_one)
-      TextileArticle.create!(:name => "blog two - post #{month}", :profile => profile, :parent => blog_two)
+      create(TextileArticle, :name => "blog one - post #{month}", :profile_id => profile.id, :parent_id => blog_one.id)
+      create(TextileArticle, :name => "blog two - post #{month}", :profile_id => profile.id, :parent_id => blog_two.id)
     end
     block = BlogArchivesBlock.new
     block.stubs(:owner).returns(profile)
@@ -11,7 +11,7 @@ class BlogHelperTest &lt; Test::Unit::TestCase
     stubs(:show_date).returns('')
     @environment = Environment.default
     @profile = create_user('blog_helper_test').person
-    @blog = Blog.create!(:profile => profile, :name => 'Blog test')
+    @blog = fast_create(Blog, :profile_id => profile.id, :name => 'Blog test')
   end
  
   attr :profile
@@ -28,7 +28,7 @@ class BlogTest &lt; ActiveSupport::TestCase
  
   should 'create rss feed automatically' do
     p = create_user('testuser').person
-    b = Blog.create!(:profile => p, :name => 'blog_feed_test')
+    b = create(Blog, :profile_id => p.id, :name => 'blog_feed_test')
     assert_kind_of RssFeed, b.feed
   end
  
@@ -61,37 +61,37 @@ class BlogTest &lt; ActiveSupport::TestCase
  
   should 'has posts' do
     p = create_user('testuser').person
-    blog = Blog.create!(:profile => p, :name => 'Blog test')
-    post = TextileArticle.create!(:name => 'First post', :profile => p, :parent => blog)
+    blog = fast_create(Blog, :profile_id => p.id, :name => 'Blog test')
+    post = fast_create(TextileArticle, :name => 'First post', :profile_id => p.id, :parent_id => blog.id)
     blog.children << post
     assert_includes blog.posts, post
   end
  
   should 'not includes rss feed in posts' do
     p = create_user('testuser').person
-    blog = Blog.create!(:profile => p, :name => 'Blog test')
+    blog = create(Blog, :profile_id => p.id, :name => 'Blog test')
     assert_includes blog.children, blog.feed
     assert_not_includes blog.posts, blog.feed
   end
  
   should 'list posts ordered by published at' do
     p = create_user('testuser').person
-    blog = Blog.create!(:profile => p, :name => 'Blog test')
-    newer = TextileArticle.create!(:name => 'Post 2', :parent => blog, :profile => p)
-    older = TextileArticle.create!(:name => 'Post 1', :parent => blog, :profile => p, :published_at => Time.now - 1.month)
+    blog = fast_create(Blog, :profile_id => p.id, :name => 'Blog test')
+    newer = create(TextileArticle, :name => 'Post 2', :parent => blog, :profile => p)
+    older = create(TextileArticle, :name => 'Post 1', :parent => blog, :profile => p, :published_at => Time.now - 1.month)
     assert_equal [newer, older], blog.posts
   end
  
   should 'has filter' do
     p = create_user('testuser').person
-    blog = Blog.create!(:profile => p, :name => 'Blog test')
+    blog = fast_create(Blog, :profile_id => p.id, :name => 'Blog test')
     blog.filter = {:param => 'value'}
     assert_equal 'value', blog.filter[:param]
   end
  
   should 'has one external feed' do
     p = create_user('testuser').person
-    blog = Blog.create!(:profile => p, :name => 'Blog test')
+    blog = fast_create(Blog, :profile_id => p.id, :name => 'Blog test')
     efeed = blog.create_external_feed(:address => 'http://invalid.url')
     assert_equal efeed, blog.external_feed
   end
@@ -135,7 +135,7 @@ class BlogTest &lt; ActiveSupport::TestCase
  
   should 'profile has more then one blog' do
     p = create_user('testuser').person
-    Blog.create!(:name => 'Blog test', :profile => p)
+    fast_create(Blog, :name => 'Blog test', :profile_id => p.id)
     assert_nothing_raised ActiveRecord::RecordInvalid do
       Blog.create!(:name => 'Another Blog', :profile => p)
     end
@@ -8,47 +8,39 @@ class CommentNotifierTest &lt; Test::Unit::TestCase
     ActionMailer::Base.delivery_method = :test
     ActionMailer::Base.perform_deliveries = true
     ActionMailer::Base.deliveries = []
-
+    @profile = create_user('user_comment_test').person
+    @article = fast_create(Article, :name => 'Article test', :profile_id => @profile.id, :notify_comments => true)
   end
  
   should 'deliver mail after make aarticle commment' do
-    p = create_user('user_comment_test').person
-    a = Article.create!(:name => 'Article test', :profile => p, :notify_comments => true)
     assert_difference ActionMailer::Base.deliveries, :size do
-      a.comments << Comment.new(:author => p, :title => 'test comment', :body => 'you suck!')
+      @article.comments << Comment.new(:author => @profile, :title => 'test comment', :body => 'you suck!')
     end
   end
  
   should 'deliver mail to owner of article' do
-    p = create_user('user_comment_test').person
-    a = Article.create!(:name => 'Article test', :profile => p, :notify_comments => true)
-    a.comments << Comment.new(:author => p, :title => 'test comment', :body => 'you suck!')
+    @article.comments << Comment.new(:author => @profile, :title => 'test comment', :body => 'you suck!')
     sent = ActionMailer::Base.deliveries.first
-    assert_equal [p.email], sent.to
+    assert_equal [@profile.email], sent.to
   end
  
   should 'display author name in delivered mail' do
-    p = create_user('user_comment_test').person
-    a = Article.create!(:name => 'Article test', :profile => p, :notify_comments => true)
-    a.comments << Comment.new(:author => p, :title => 'test comment', :body => 'you suck!')
+    @article.comments << Comment.new(:author => @profile, :title => 'test comment', :body => 'you suck!')
     sent = ActionMailer::Base.deliveries.first
     assert_match /user_comment_test/, sent.body
   end
  
   should 'display unauthenticated author name and email in delivered mail' do
-    p = create_user('user_comment_test').person
-    a = Article.create!(:name => 'Article test', :profile => p, :notify_comments => true)
-    a.comments << Comment.new(:name => 'flatline', :email => 'flatline@invalid.com', :title => 'test comment', :body => 'you suck!')
+    @article.comments << Comment.new(:name => 'flatline', :email => 'flatline@invalid.com', :title => 'test comment', :body => 'you suck!')
     sent = ActionMailer::Base.deliveries.first
     assert_match /flatline/, sent.body
     assert_match /flatline@invalid.com/, sent.body
   end
  
   should 'not deliver mail if notify comments is false' do
-    p = create_user('user_comment_test').person
-    a = Article.create!(:name => 'Article test', :profile => p, :notify_comments => false)
+    @article.update_attribute(:notify_comments, false)
     assert_no_difference ActionMailer::Base.deliveries, :size do
-      a.comments << Comment.new(:author => p, :title => 'test comment', :body => 'you suck!')
+      @article.comments << Comment.new(:author => @profile, :title => 'test comment', :body => 'you suck!')
     end
   end
  
@@ -121,7 +121,7 @@ class CommunitiesBlockTest &lt; Test::Unit::TestCase
     community_public = fast_create(Community, :environment_id => Environment.default.id, :public_profile => true)
     community_public.add_member(user)
  
-    community_private = fast_create(Community, :environment_id => Environment.default.id, :public_profile => false)
+    community_private = fast_create(Community, :public_profile => false)
     community_private.add_member(user)
  
     block = CommunitiesBlock.new
@@ -133,10 +133,10 @@ class CommunitiesBlockTest &lt; Test::Unit::TestCase
   should 'not count non-visible profile communities' do
     user = create_user('testuser').person
  
-    visible_community = Community.create!(:name => 'tcommunity 1', :identifier => 'comm1', :environment => Environment.default, :visible => true)
+    visible_community = fast_create(Community, :name => 'tcommunity 1', :identifier => 'comm1', :visible => true)
     visible_community.add_member(user)
  
-    not_visible_community = Community.create!(:name => ' community 2', :identifier => 'comm2', :environment => Environment.default, :visible => false)
+    not_visible_community = fast_create(Community, :name => ' community 2', :identifier => 'comm2', :visible => false)
     not_visible_community.add_member(user)
  
     block = CommunitiesBlock.new
@@ -146,9 +146,9 @@ class CommunitiesBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'count non-public environment communities' do
-    community_public = Community.create!(:name => 'tcommunity 1', :identifier => 'comm1', :environment => Environment.default, :public_profile => true)
+    community_public = fast_create(Community, :name => 'tcommunity 1', :identifier => 'comm1', :public_profile => true)
  
-    community_private = Community.create!(:name => ' community 2', :identifier => 'comm2', :environment => Environment.default, :public_profile => false)
+    community_private = fast_create(Community, :name => ' community 2', :identifier => 'comm2', :public_profile => false)
  
     block = CommunitiesBlock.new
     block.expects(:owner).at_least_once.returns(Environment.default)
@@ -157,9 +157,9 @@ class CommunitiesBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'not count non-visible environment communities' do
-    visible_community = Community.create!(:name => 'tcommunity 1', :identifier => 'comm1', :environment => Environment.default, :visible => true)
+    visible_community = fast_create(Community, :name => 'tcommunity 1', :identifier => 'comm1', :visible => true)
  
-    not_visible_community = Community.create!(:name => ' community 2', :identifier => 'comm2', :environment => Environment.default, :visible => false)
+    not_visible_community = fast_create(Community, :name => ' community 2', :identifier => 'comm2', :visible => false)
  
     block = CommunitiesBlock.new
     block.expects(:owner).at_least_once.returns(Environment.default)
@@ -51,7 +51,7 @@ class CommunityTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to add new members' do
-    c = Community.create!(:environment => Environment.default, :name => 'my test profile', :identifier => 'mytestprofile')
+    c = fast_create(Community, :name => 'my test profile', :identifier => 'mytestprofile')
     p = create_user('mytestuser').person
  
     c.add_member(p)
@@ -60,7 +60,7 @@ class CommunityTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to remove members' do
-    c = Community.create!(:environment => Environment.default, :name => 'my other test profile', :identifier => 'myothertestprofile')
+    c = fast_create(Community, :name => 'my other test profile', :identifier => 'myothertestprofile')
     p = create_user('myothertestuser').person
  
     c.add_member(p)
@@ -71,7 +71,7 @@ class CommunityTest &lt; Test::Unit::TestCase
   end
  
   should 'clear relationships after destroy' do
-    c = Community.create!(:environment => Environment.default, :name => 'my test profile', :identifier => 'mytestprofile')
+    c = fast_create(Community, :name => 'my test profile', :identifier => 'mytestprofile')
     member = create_user('memberuser').person
     admin = create_user('adminuser').person
     moderator = create_user('moderatoruser').person
@@ -91,7 +91,7 @@ class CommunityTest &lt; Test::Unit::TestCase
  
   should 'have a community template' do
     env = Environment.create!(:name => 'test env')
-    p = Community.create!(:environment => Environment.default, :name => 'test_com', :identifier => 'test_com', :environment => env)
+    p = Community.create!(:name => 'test_com', :identifier => 'test_com', :environment => env)
     assert_kind_of Community, p.template
   end
  
@@ -124,28 +124,28 @@ class CommunityTest &lt; Test::Unit::TestCase
   end
  
   should 'return newest text articles as news' do
-    c = Community.create!(:name => 'test_com')
-    f = Folder.create!(:name => 'folder', :profile => c)
+    c = fast_create(Community, :name => 'test_com')
+    f = fast_create(Folder, :name => 'folder', :profile_id => c.id)
     u = UploadedFile.create!(:profile => c, :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'))
-    older_t = TinyMceArticle.create!(:name => 'old news', :profile => c)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c)
-    t_in_f = TinyMceArticle.create!(:name => 'news', :profile => c, :parent => f)
+    older_t = fast_create(TinyMceArticle, :name => 'old news', :profile_id => c.id)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id)
+    t_in_f = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id, :parent_id => f.id)
  
     assert_equal [t_in_f, t], c.news(2)
   end
  
   should 'not return highlighted news when not asked' do
-    c = Community.create!(:name => 'test_com')
-    highlighted_t = TinyMceArticle.create!(:name => 'high news', :profile => c, :highlighted => true)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c)
+    c = fast_create(Community, :name => 'test_com')
+    highlighted_t = fast_create(TinyMceArticle, :name => 'high news', :profile_id => c.id, :highlighted => true)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id)
  
     assert_equal [t].map(&:slug), c.news(2).map(&:slug)
   end
  
   should 'return highlighted news when asked' do
-    c = Community.create!(:name => 'test_com')
-    highlighted_t = TinyMceArticle.create!(:name => 'high news', :profile => c, :highlighted => true)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c)
+    c = fast_create(Community, :name => 'test_com')
+    highlighted_t = fast_create(TinyMceArticle, :name => 'high news', :profile_id => c.id, :highlighted => true)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id)
  
     assert_equal [highlighted_t].map(&:slug), c.news(2, true).map(&:slug)
   end
@@ -32,13 +32,13 @@ class ContactTest &lt; ActiveSupport::TestCase
   end
  
   should 'deliver message' do
-    ent = Enterprise.create!(:name => 'my enterprise', :identifier => 'myent', :environment => Environment.default)
+    ent = fast_create(Enterprise, :name => 'my enterprise', :identifier => 'myent')
     c = Contact.new(:name => 'john', :email => 'john@invalid.com', :subject => 'hi', :message => 'hi, all', :dest => ent)
     assert c.deliver
   end
  
   should 'not deliver message if contact is invalid' do
-    ent = Enterprise.create!(:name => 'my enterprise', :identifier => 'myent', :environment => Environment.default)
+    ent = fast_create(Enterprise, :name => 'my enterprise', :identifier => 'myent')
     c = Contact.new(:name => 'john', :subject => 'hi', :message => 'hi, all', :dest => ent)
     assert !c.valid?
     assert !c.deliver
@@ -13,7 +13,7 @@ class ContentViewerHelperTest &lt; Test::Unit::TestCase
   attr :profile
  
   should 'display published-at for blog posts' do
-    blog = Blog.create!(:name => 'Blog test', :profile => profile)
+    blog = fast_create(Blog, :name => 'Blog test', :profile_id => profile.id)
     post = TextileArticle.create!(:name => 'post test', :profile => profile, :parent => blog)
     result = article_title(post)
     assert_match /#{show_date(post.published_at)}, by .*#{profile.identifier}/, result
@@ -26,22 +26,22 @@ class ContentViewerHelperTest &lt; Test::Unit::TestCase
   end
  
   should 'create link on title of blog posts' do
-    blog = Blog.create!(:name => 'Blog test', :profile => profile)
-    post = TextileArticle.create!(:name => 'post test', :profile => profile, :parent => blog)
+    blog = fast_create(Blog, :name => 'Blog test', :profile_id => profile.id)
+    post = fast_create(TextileArticle, :name => 'post test', :profile_id => profile.id, :parent_id => blog.id)
     assert post.belongs_to_blog?
     result = article_title(post)
     assert_match /a href='#{post.url}'>#{post.name}</, result
   end
  
   should 'not create link on title if pass no_link option' do
-    blog = Blog.create!(:name => 'Blog test', :profile => profile)
-    post = TextileArticle.create!(:name => 'post test', :profile => profile, :parent => blog)
+    blog = fast_create(Blog, :name => 'Blog test', :profile_id => profile.id)
+    post = fast_create(TextileArticle, :name => 'post test', :profile_id => profile.id, :parent_id => blog.id)
     result = article_title(post, :no_link => :true)
     assert_no_match /a href='#{post.url}'>#{post.name}</, result
   end
  
   should 'not create link on title if non-blog post' do
-    article = TextileArticle.create!(:name => 'art test', :profile => profile)
+    article = fast_create(TextileArticle, :name => 'art test', :profile_id => profile.id)
     result = article_title(article)
     assert_no_match /a href='#{article.url}'>#{article.name}</, result
   end
@@ -46,8 +46,8 @@ class CreateEnterpriseTest &lt; Test::Unit::TestCase
  
   should 'require that the informed target (validator organization) actually validates for the chosen region' do
     environment = fast_create(Environment)
-    region = Region.create!(:name => 'My region', :environment_id => environment.id)
-    validator = Organization.create!(:name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
+    region = fast_create(Region, :name => 'My region', :environment_id => environment.id)
+    validator = fast_create(Organization, :name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
  
     task = CreateEnterprise.new
  
@@ -94,8 +94,8 @@ class CreateEnterpriseTest &lt; Test::Unit::TestCase
   should 'actually create an enterprise when finishing the task and associate the task requestor as its owner through the "user" association' do
  
     environment = fast_create(Environment)
-    region = Region.create!(:name => 'My region', :environment_id => environment.id)
-    validator = Organization.create!(:name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
+    region = fast_create(Region, :name => 'My region', :environment_id => environment.id)
+    validator = fast_create(Organization, :name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
     region.validators << validator
     person = create_user('testuser').person
  
@@ -128,8 +128,8 @@ class CreateEnterpriseTest &lt; Test::Unit::TestCase
   should 'actually create an enterprise when finishing the task and associate the task requestor as its owner through the "user" association even when environment is not default' do
  
     environment = fast_create(Environment)
-    region = Region.create!(:name => 'My region', :environment_id => environment.id)
-    validator = Organization.create!(:name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
+    region = fast_create(Region, :name => 'My region', :environment_id => environment.id)
+    validator = fast_create(Organization, :name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
     region.validators << validator
     person = create_user('testuser').person
  
@@ -170,8 +170,8 @@ class CreateEnterpriseTest &lt; Test::Unit::TestCase
  
   should 'validate that eveything is ok but the validator (target)' do
     environment = fast_create(Environment)
-    region = Region.create!(:name => 'My region', :environment_id => environment.id)
-    validator = Organization.create!(:name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
+    region = fast_create(Region, :name => 'My region', :environment_id => environment.id)
+    validator = fast_create(Organization, :name => "My organization", :identifier => 'myorg', :environment_id => environment.id)
     region.validators << validator
     person = create_user('testuser').person
     task = CreateEnterprise.new({
@@ -7,7 +7,7 @@ class DisabledEnterpriseMessageBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'display message for disabled enterprise' do
-    e = Environment.create(:name => 'test_env')
+    e = Environment.default
     e.expects(:message_for_disabled_enterprise).returns('This message is for disabled enterprises')
     block = DisabledEnterpriseMessageBlock.new
     p = Profile.new
@@ -19,7 +19,7 @@ class DisabledEnterpriseMessageBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'display nothing if environment has no message' do
-    e = Environment.create(:name => 'test_env')
+    e = fast_create(Environment)
     block = DisabledEnterpriseMessageBlock.new
     p = Profile.new
     block.expects(:owner).returns(p)
@@ -51,7 +51,7 @@ class DomainTest &lt; Test::Unit::TestCase
  
   def test_find_by_name
     Domain.delete_all
-    Domain.create(:name => 'example.net')
+    fast_create(Domain, :name => 'example.net')
     d1 = Domain.find_by_name('example.net')
     d2 =  Domain.find_by_name('www.example.net')
     assert !d1.nil?
@@ -25,7 +25,7 @@ class EmailActivationTest &lt; Test::Unit::TestCase
   should 'enable user email when finish' do
     ze = create_user('zezinho', :environment_id => Environment.default.id)
     assert !ze.enable_email
-    task = EmailActivation.create!(:requestor => ze.person, :target => Environment.default)
+    task = fast_create(EmailActivation, :requestor_id => ze.person.id, :target_id => Environment.default.id)
     task.finish
     ze.reload
     assert ze.enable_email
@@ -46,7 +46,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'remove products when removing enterprise' do
-    e = Enterprise.create!(:name => "My enterprise", :identifier => 'myenterprise')
+    e = fast_create(Enterprise)
     e.products.build(:name => 'One product').save!
     e.products.build(:name => 'Another product').save!
  
@@ -77,7 +77,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'be found in search for its product categories' do
-    ent1 = Enterprise.create!(:name => 'test1', :identifier => 'test1')
+    ent1 = fast_create(Enterprise)
     prod_cat = ProductCategory.create!(:name => 'pctest', :environment => Environment.default)
     prod = ent1.products.create!(:name => 'teste', :product_category => prod_cat)
  
@@ -90,7 +90,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
    should 'be found in search for its product categories hierarchy' do
-    ent1 = Enterprise.create!(:name => 'test1', :identifier => 'test1')
+    ent1 = fast_create(Enterprise)
     prod_cat = ProductCategory.create!(:name => 'pctest', :environment => Environment.default)
     prod_child = ProductCategory.create!(:name => 'pchild', :environment => Environment.default, :parent => prod_cat)
     prod = ent1.products.create!(:name => 'teste', :product_category => prod_child)
@@ -104,7 +104,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'not allow to add new members' do
-    o = Enterprise.create!(:name => 'my test profile', :identifier => 'mytestprofile')
+    o = fast_create(Enterprise)
     p = create_user('mytestuser').person
  
     o.add_member(p)
@@ -114,7 +114,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to remove members' do
-    c = Enterprise.create!(:name => 'my other test profile', :identifier => 'myothertestprofile')
+    c = fast_create(Enterprise)
     c.expects(:closed?).returns(false)
     p = create_user('myothertestuser').person
  
@@ -126,27 +126,27 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'have foudation_year' do
-    ent = Enterprise.create!(:name => 'test enteprise', :identifier => 'test_ent')
+    ent = fast_create(Enterprise)
  
     assert_respond_to ent, 'foundation_year'
     assert_respond_to ent, 'foundation_year='
   end
  
   should 'have cnpj' do
-    ent = Enterprise.create!(:name => 'test enteprise', :identifier => 'test_ent')
+    ent = fast_create(Enterprise)
  
     assert_respond_to ent, 'cnpj'
     assert_respond_to ent, 'cnpj='
   end
  
   should 'block' do
-    ent = Enterprise.create!(:name => 'test enteprise', :identifier => 'test_ent')
+    ent = fast_create(Enterprise)
     ent.block
     assert Enterprise.find(ent.id).blocked?
   end
  
   should 'unblock' do
-    ent = Enterprise.create!(:name => 'test enteprise', :identifier => 'test_ent')
+    ent = fast_create(Enterprise)
     ent.data[:blocked] = true
     ent.save
     ent.unblock
@@ -154,7 +154,7 @@ class EnterpriseTest &lt; Test::Unit::TestCase
   end
  
   should 'enable and make user admin' do
-    ent = Enterprise.create!(:name => 'test enteprise', :identifier => 'test_ent', :enabled => false)
+    ent = fast_create(Enterprise, :enabled => false)
     p = create_user('test_user').person
  
     assert ent.enable(p)
@@ -125,11 +125,11 @@ class EnterprisesBlockTest &lt; Test::Unit::TestCase
   should 'count number of owner enterprises' do
     user = create_user('testuser').person
  
-    ent1 = Enterprise.create!(:name => 'test enterprise 1', :identifier => 'ent1', :environment => Environment.default)
+    ent1 = fast_create(Enterprise, :name => 'test enterprise 1', :identifier => 'ent1')
     ent1.expects(:closed?).returns(false)
     ent1.add_member(user)
  
-    ent2 = Enterprise.create!(:name => 'test enterprise 2', :identifier => 'ent2', :environment => Environment.default)
+    ent2 = fast_create(Enterprise, :name => 'test enterprise 2', :identifier => 'ent2')
     ent2.expects(:closed?).returns(false)
     ent2.add_member(user)
  
@@ -186,9 +186,9 @@ class EnterprisesBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'not count non-visible environment enterprises' do
-    env = Environment.create!(:name => 'test_env')
-    ent1 = Enterprise.create!(:name => 'test enterprise 1', :identifier => 'ent1', :environment => env, :visible => true)
-    ent2 = Enterprise.create!(:name => 'test enterprise 2', :identifier => 'ent2', :environment => env, :visible => false)
+    env = fast_create(Environment)
+    ent1 = fast_create(Enterprise, :name => 'test enterprise 1', :identifier => 'ent1', :environment_id => env.id, :visible => true)
+    ent2 = fast_create(Enterprise, :name => 'test enterprise 2', :identifier => 'ent2', :environment_id => env.id, :visible => false)
  
     block = EnterprisesBlock.new
     block.expects(:owner).at_least_once.returns(env)
@@ -107,9 +107,9 @@ class EnvironmentTest &lt; Test::Unit::TestCase
  
   def test_should_list_top_level_categories
     env = fast_create(Environment)
-    cat1 = Category.create!(:name => 'first category', :environment_id => env.id)
-    cat2 = Category.create!(:name => 'second category', :environment_id => env.id)
-    subcat = Category.create!(:name => 'child category', :environment_id => env.id, :parent_id => cat2.id)
+    cat1 = fast_create(Category, :name => 'first category', :environment_id => env.id)
+    cat2 = fast_create(Category, :name => 'second category', :environment_id => env.id)
+    subcat = fast_create(Category, :name => 'child category', :environment_id => env.id, :parent_id => cat2.id)
  
     cats = env.top_level_categories
     assert_equal 2, cats.size
@@ -120,9 +120,9 @@ class EnvironmentTest &lt; Test::Unit::TestCase
  
   def test_should_list_all_categories
     env = fast_create(Environment)
-    cat1 = Category.create!(:name => 'first category', :environment_id => env.id)
-    cat2 = Category.create!(:name => 'second category', :environment_id => env.id)
-    subcat = Category.create!(:name => 'child category', :environment_id => env.id, :parent_id => cat2.id)
+    cat1 = fast_create(Category, :name => 'first category', :environment_id => env.id)
+    cat2 = fast_create(Category, :name => 'second category', :environment_id => env.id)
+    subcat = fast_create(Category, :name => 'child category', :environment_id => env.id, :parent_id => cat2.id)
  
     cats = env.categories
     assert_equal 3, cats.size
@@ -315,21 +315,21 @@ class EnvironmentTest &lt; Test::Unit::TestCase
   should 'provide recent_documents' do
     environment = fast_create(Environment)
  
-    p1 = environment.profiles.build(:identifier => 'testprofile1', :name => 'test profile 1'); p1.save!
-    p2 = environment.profiles.build(:identifier => 'testprofile2', :name => 'test profile 2'); p2.save!
+    p1 = fast_create(Profile, :environment_id => environment.id)
+    p2 = fast_create(Profile, :environment_id => environment.id)
  
     # clear the articles
     Article.destroy_all
  
     # p1 creates one article
-    doc1 = p1.articles.build(:name => 'text 1'); doc1.save!
+    doc1 = fast_create(Article, :profile_id => p1.id)
  
     # p2 creates two articles
-    doc2 = p2.articles.build(:name => 'text 2'); doc2.save!
-    doc3 = p2.articles.build(:name => 'text 3'); doc3.save!
+    doc2 = fast_create(Article, :profile_id => p2.id)
+    doc3 = fast_create(Article, :profile_id => p2.id)
  
     # p1 creates another article
-    doc4 = p1.articles.build(:name => 'text 4'); doc4.save!
+    doc4 = fast_create(Article, :profile_id => p1.id)
  
     all_recent = environment.recent_documents
     [doc1,doc2,doc3,doc4].each do |item|
@@ -404,34 +404,10 @@ class EnvironmentTest &lt; Test::Unit::TestCase
     assert_equal 'this enterprise was disabled', env.message_for_disabled_enterprise
   end
  
-  should 'have articles and text_articles' do
-    # FIXME 
-    assert true
-    #environment = Environment.create(:name => 'a test environment')
-
-    ## creates profile
-    #profile = environment.profiles.create!(:identifier => 'testprofile1', :name => 'test profile 1')
-
-    ## profile creates one article
-    #article = profile.articles.create!(:name => 'text article')
-
-    ## profile creates one textile article
-    #textile = TextileArticle.create!(:name => 'textile article', :profile => profile)
-    #profile.articles << textile
-
-    #assert_includes environment.articles, article
-    #assert_includes environment.articles, textile
-
-    #assert_includes environment.text_articles, textile
-    #assert_not_includes environment.text_articles, article
-  end
-
   should 'find by contents from articles' do
     environment = fast_create(Environment)
     assert_nothing_raised do
       environment.articles.find_by_contents('')
-      # FIXME
-      #environment.text_articles.find_by_contents('')
     end
   end
  
@@ -768,7 +744,7 @@ class EnvironmentTest &lt; Test::Unit::TestCase
     e = Environment.default
  
     c = e.portal_community = fast_create(Community)
-    news_folder = Folder.create!(:name => 'news folder', :profile => c)
+    news_folder = fast_create(Folder, :name => 'news folder', :profile_id => c.id)
  
     e.portal_folders = [news_folder]
     e.save!; e.reload
@@ -848,9 +824,9 @@ class EnvironmentTest &lt; Test::Unit::TestCase
  
   should 'list tags with their counts' do
     person = fast_create(Person)
-    person.articles.build(:name => 'article 1', :tag_list => 'first-tag').save!
-    person.articles.build(:name => 'article 2', :tag_list => 'first-tag, second-tag').save!
-    person.articles.build(:name => 'article 3', :tag_list => 'first-tag, second-tag, third-tag').save!
+    person.articles.create!(:name => 'article 1', :tag_list => 'first-tag')
+    person.articles.create!(:name => 'article 2', :tag_list => 'first-tag, second-tag')
+    person.articles.create!(:name => 'article 3', :tag_list => 'first-tag, second-tag, third-tag')
  
     assert_equal({ 'first-tag' => 3, 'second-tag' => 2, 'third-tag' => 1 }, Environment.default.tag_counts)
   end
@@ -172,7 +172,7 @@ class EventTest &lt; ActiveSupport::TestCase
   end
  
   should 'list all events' do
-    profile = Profile.create!(:name => "Test Profile", :identifier => 'testprofile')
+    profile = fast_create(Profile)
     event1 = Event.new(:name => 'Ze Birthday', :start_date => Date.today)
     event2 = Event.new(:name => 'Mane Birthday', :start_date => Date.today >> 1)
     profile.events << [event1, event2]
@@ -181,7 +181,7 @@ class EventTest &lt; ActiveSupport::TestCase
   end
  
   should 'list events by day' do
-    profile = Profile.create!(:name => "Test Profile", :identifier => 'testprofile')
+    profile = fast_create(Profile)
  
     today = Date.today
     yesterday_event = Event.new(:name => 'Joao Birthday', :start_date => today - 1.day)
@@ -194,7 +194,7 @@ class EventTest &lt; ActiveSupport::TestCase
   end
  
   should 'list events in a range' do
-    profile = Profile.create!(:name => "Test Profile", :identifier => 'testprofile')
+    profile = fast_create(Profile)
  
     today = Date.today
     event_in_range = Event.new(:name => 'Noosfero Conference', :start_date => today - 2.day, :end_date => today + 2.day)
@@ -208,7 +208,7 @@ class EventTest &lt; ActiveSupport::TestCase
   end
  
   should 'not list events out of range' do
-    profile = Profile.create!(:name => "Test Profile", :identifier => 'testprofile')
+    profile = fast_create(Profile)
  
     today = Date.today
     event_in_range1 = Event.new(:name => 'Foswiki Conference', :start_date => today - 2.day, :end_date => today + 2.day)
@@ -63,9 +63,9 @@ class FavoriteEnterprisesBlockTest &lt; ActiveSupport::TestCase
   should 'count number of owner favorite enterprises' do
     user = create_user('testuser').person
  
-    ent1 = Enterprise.create!(:name => 'test enterprise 1', :identifier => 'ent1', :environment => Environment.default)
+    ent1 = fast_create(Enterprise, :name => 'test enterprise 1', :identifier => 'ent1')
  
-    ent2 = Enterprise.create!(:name => 'test enterprise 2', :identifier => 'ent2', :environment => Environment.default)
+    ent2 = fast_create(Enterprise, :name => 'test enterprise 2', :identifier => 'ent2')
  
     user.favorite_enterprises << [ent1, ent2]
  
@@ -24,13 +24,13 @@ class FolderTest &lt; ActiveSupport::TestCase
  
   should 'can display hits' do
     profile = create_user('testuser').person
-    a = Folder.create!(:name => 'Test article', :profile => profile)
+    a = fast_create(Folder, :profile_id => profile.id)
     assert_equal false, a.can_display_hits?
   end
  
   should 'be viewed as image gallery' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
     f.view_as = 'image_gallery'; f.save!
     f.reload
  
@@ -39,14 +39,14 @@ class FolderTest &lt; ActiveSupport::TestCase
  
   should 'not allow view as bogus' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
     f.view_as = 'bogus'
     assert !f.save
   end
  
   should 'view as folder by default' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
     f.expects(:folder)
     f.to_html
  
@@ -55,60 +55,60 @@ class FolderTest &lt; ActiveSupport::TestCase
  
   should 'have images that are only images or other folders' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
     file = UploadedFile.create!(:uploaded_data => fixture_file_upload('/files/test.txt', 'text/plain'), :parent => f, :profile => p)
     image = UploadedFile.create!(:uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'), :parent => f, :profile => p)
-    folder = Folder.create!(:name => 'child test folder', :parent => f, :profile => p)
+    folder = fast_create(Folder, :profile_id => p.id, :parent_id => f.id)
  
     assert_equivalent [folder, image], f.images
   end
  
   should 'bring folders first in alpha order in images listing' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
-    folder1 = Folder.create!(:name => 'child test folder 1', :parent => f, :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
+    folder1 = fast_create(Folder, :name => 'b', :profile_id => p.id, :parent_id => f.id)
     image = UploadedFile.create!(:uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'), :parent => f, :profile => p)
-    folder2 = Folder.create!(:name => 'child test folder 2', :parent => f, :profile => p)
-    folder3 = Folder.create!(:name => 'another child test folder', :parent => f, :profile => p)
+    folder2 = fast_create(Folder, :name => 'c', :profile_id => p.id, :parent_id => f.id)
+    folder3 = fast_create(Folder, :name => 'a', :profile_id => p.id, :parent_id => f.id)
  
     assert_equal [folder3.id, folder1.id, folder2.id, image.id], f.images.map(&:id)
   end
  
   should 'images support pagination' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'Test folder', :profile => p)
-    folder = Folder.create!(:name => 'child test folder', :parent => f, :profile => p)
+    f = fast_create(Folder, :profile_id => p.id)
+    folder = fast_create(Folder, :profile_id => p.id, :parent_id => f.id)
     image = UploadedFile.create!(:uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'), :parent => f, :profile => p)
  
     assert_equal [image], f.images.paginate(:page => 2, :per_page => 1)
   end
  
   should 'return newest text articles as news' do
-    c = Community.create!(:name => 'test_com')
-    folder = Folder.create!(:name => 'folder', :profile => c)
-    f = Folder.create!(:name => 'folder', :profile => c, :parent => folder)
+    c = fast_create(Community)
+    folder = fast_create(Folder, :profile_id => c.id)
+    f = fast_create(Folder, :name => 'folder', :profile_id => c.id, :parent_id => folder.id)
     u = UploadedFile.create!(:profile => c, :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'), :parent => folder)
-    older_t = TinyMceArticle.create!(:name => 'old news', :profile => c, :parent => folder)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c, :parent => folder)
-    t_in_f = TinyMceArticle.create!(:name => 'news', :profile => c, :parent => f)
+    older_t = fast_create(TinyMceArticle, :name => 'old news', :profile_id => c.id, :parent_id => folder.id)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id, :parent_id => folder.id)
+    t_in_f = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id, :parent_id => f.id)
  
     assert_equal [t], folder.news(1)
   end
  
   should 'not return highlighted news when not asked' do
-    c = Community.create!(:name => 'test_com')
-    folder = Folder.create!(:name => 'folder', :profile => c)
-    highlighted_t = TinyMceArticle.create!(:name => 'high news', :profile => c, :highlighted => true, :parent => folder)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c, :parent => folder)
+    c = fast_create(Community)
+    folder = fast_create(Folder, :profile_id => c.id)
+    highlighted_t = fast_create(TinyMceArticle, :name => 'high news', :profile_id => c.id, :highlighted => true, :parent_id => folder.id)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id, :parent_id => folder.id)
  
     assert_equal [t].map(&:slug), folder.news(2).map(&:slug)
   end
  
   should 'return highlighted news when asked' do
-    c = Community.create!(:name => 'test_com')
-    folder = Folder.create!(:name => 'folder', :profile => c)
-    highlighted_t = TinyMceArticle.create!(:name => 'high news', :profile => c, :highlighted => true, :parent => folder)
-    t = TinyMceArticle.create!(:name => 'news', :profile => c, :parent => folder)
+    c = fast_create(Community)
+    folder = fast_create(Folder, :profile_id => c.id)
+    highlighted_t = fast_create(TinyMceArticle, :name => 'high news', :profile_id => c.id, :highlighted => true, :parent_id => folder.id)
+    t = fast_create(TinyMceArticle, :name => 'news', :profile_id => c.id, :parent_id => folder.id)
  
     assert_equal [highlighted_t].map(&:slug), folder.news(2, true).map(&:slug)
   end
@@ -117,8 +117,8 @@ class FolderTest &lt; ActiveSupport::TestCase
     p = create_user('test_user').person
     i = UploadedFile.create!(:profile => p, :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'))
  
-    c = Community.create!(:name => 'test_com')
-    folder = Folder.create!(:name => 'folder', :profile => c)
+    c = fast_create(Community)
+    folder = fast_create(Folder, :profile_id => c.id)
     pi = PublishedArticle.create!(:profile => c, :reference_article => i, :parent => folder)
  
     assert_includes folder.images(true), pi
@@ -4,7 +4,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   fixtures :profiles
  
   def create_create_enterprise(org)
-    region = Region.create!(:name => 'some region', :environment => Environment.default)
+    region = fast_create(Region, :name => 'some region')
     region.validators << org
  
     requestor = create_user('testreq').person
@@ -130,7 +130,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'be able to find a pending validation by its code' do
-    org = Organization.create!(:name => 'test org', :identifier => 'testorg')
+    org = fast_create(Organization)
  
     validation = create_create_enterprise(org)
  
@@ -148,7 +148,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'be able to find an already processed validation by its code' do
-    org = Organization.create!(:name => 'test org', :identifier => 'testorg')
+    org = fast_create(Organization)
     validation = create_create_enterprise(org)
     validation.finish
  
@@ -167,7 +167,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'update contact_person' do
-    org = Organization.create!(:name => 'test org', :identifier => 'testorg')
+    org = fast_create(Organization)
     assert_nil org.contact_person
     org.contact_person = 'person'
     assert_not_nil org.contact_person
@@ -197,7 +197,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to add new member' do
-    o = Organization.create!(:name => 'my test profile', :identifier => 'mytestprofile')
+    o = fast_create(Organization)
     p = create_user('mytestuser').person
  
     o.add_member(p)
@@ -206,7 +206,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to remove members' do
-    c = Organization.create!(:name => 'my other test profile', :identifier => 'myothertestprofile')
+    c = fast_create(Organization)
     p = create_user('myothertestuser').person
  
     c.add_member(p)
@@ -217,7 +217,7 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'allow to add new moderator' do
-    o = Organization.create!(:name => 'my test profile', :identifier => 'mytestprofile')
+    o = fast_create(Organization)
     p = create_user('myanothertestuser').person
  
     o.add_moderator(p)
@@ -226,14 +226,14 @@ class OrganizationTest &lt; Test::Unit::TestCase
   end
  
   should 'moderator has moderate_comments permission' do
-    o = Organization.create!(:name => 'my test profile', :identifier => 'mytestprofile')
+    o = fast_create(Organization)
     p = create_user('myanothertestuser').person
     o.add_moderator(p)
     assert p.has_permission?(:moderate_comments, o)
   end
  
   should 'be able to change identifier' do
-    o = Organization.create!(:name => 'Test Org', :identifier => 'test_org')
+    o = fast_create(Organization)
     assert_nothing_raised do
       o.identifier = 'test_org_new_url'
     end
@@ -21,7 +21,7 @@ class PendingTaskNotifierTest &lt; Test::Unit::TestCase
  
   should 'list organization pending tasks' do
     p = create_user('maelcum').person
-    c = Community.create!(:name => 'my test community')
+    c = fast_create(Community)
     c.add_admin(p)
     c.tasks << Task.new
  
@@ -24,7 +24,7 @@ class PeopleBlockTest &lt; ActiveSupport::TestCase
   end
  
   should 'list people' do
-    owner = Environment.create!(:name => 'test environment')
+    owner = fast_create(Environment)
     block = PeopleBlock.new
     block.expects(:owner).returns(owner).at_least_once
     person1 = fast_create(Person, :environment_id => owner.id)
@@ -36,7 +36,7 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'belong to communities' do
-    c = Community.create!(:name => 'my test community')
+    c = fast_create(Community)
     p = create_user('mytestuser').person
  
     c.add_member(p)
@@ -78,7 +78,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'change the roles of the user' do
     p = create_user('jonh', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe').person
-    e = Enterprise.create(:identifier => 'enter', :name => 'Enter')
+    e = fast_create(Enterprise)
     r1 = Role.create(:name => 'associate')
     assert e.affiliate(p, r1)
     r2 = Role.create(:name => 'partner')
@@ -91,7 +91,7 @@ class PersonTest &lt; Test::Unit::TestCase
   should 'report that the user has the permission' do
     p = create_user('john', :email => 'john@doe.org', :password => 'dhoe', :password_confirmation => 'dhoe').person
     r = Role.create(:name => 'associate', :permissions => ['edit_profile'])
-    e = Enterprise.create(:identifier => 'enterpri', :name => 'Enterpri')
+    e = fast_create(Enterprise)
     assert e.affiliate(p, r)
     p = Person.find(p.id)
     assert e.reload
@@ -147,7 +147,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'be an admin if have permission of environment administration' do
     role = Role.create!(:name => 'just_another_admin_role')
-    env = Environment.create!(:name => 'blah')
+    env = fast_create(Environment)
     person = create_user('just_another_person').person
     env.affiliate(person, role)
     assert ! person.is_admin?(env)
@@ -157,8 +157,8 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'separate admins of different environments' do
-    env1 = Environment.create!(:name => 'blah1')
-    env2 = Environment.create!(:name => 'blah2')
+    env1 = fast_create(Environment)
+    env2 = fast_create(Environment)
  
     # role is an admin role
     role = Role.create!(:name => 'just_another_admin_role')
@@ -290,7 +290,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'have favorite enterprises' do
     p = create_user('test_person').person
-    e = Enterprise.create!(:name => 'test_ent', :identifier => 'test_ent')
+    e = fast_create(Enterprise)
  
     p.favorite_enterprises << e
  
@@ -325,7 +325,8 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'have e-mail addresses' do
-    env = Environment.create!(:name => 'sample env', :domains => [Domain.new(:name => 'somedomain.com')])
+    env = fast_create(Environment)
+    env.domains <<  Domain.new(:name => 'somedomain.com')
     person = Person.new(:environment => env, :identifier => 'testuser')
     person.expects(:environment).returns(env)
  
@@ -333,9 +334,9 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'not show www in e-mail addresses when force_www=true' do
-    env = Environment.create!(:name => 'sample env', :domains => [Domain.new(:name => 'somedomain.com')])
-    env.force_www = true
-    env.save
+    env = fast_create(Environment)
+    env.domains <<  Domain.new(:name => 'somedomain.com')
+    env.update_attribute(:force_www, true)
     person = Person.new(:environment => env, :identifier => 'testuser')
     person.expects(:environment).returns(env)
  
@@ -377,12 +378,12 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'person has group with pending tasks' do
     p1 = create_user('user_with_tasks').person
-    c1 = Community.create!(:name => 'my test community')
+    c1 = fast_create(Community)
     c1.tasks << Task.new
     assert !c1.tasks.pending.empty?
     c1.add_admin(p1)
  
-    c2 = Community.create!(:name => 'my other test community')
+    c2 = fast_create(Community)
     p2 = create_user('user_without_tasks').person
     c2.add_admin(p2)
  
@@ -391,7 +392,7 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'not allow simple member to view group pending tasks' do
-    c = Community.create!(:name => 'my test community')
+    c = fast_create(Community)
     c.tasks << Task.new
     p = create_user('user_without_tasks').person
     c.add_member(p)
@@ -400,7 +401,7 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'person has organization pending tasks' do
-    c = Community.create!(:name => 'my test community')
+    c = fast_create(Community)
     c.tasks << Task.new
     p = create_user('user_with_tasks').person
     c.add_admin(p)
@@ -409,7 +410,7 @@ class PersonTest &lt; Test::Unit::TestCase
   end
  
   should 'select organization pending tasks' do
-    c = Community.create!(:name => 'my test community')
+    c = fast_create(Community)
     c.tasks << Task.new
     p = create_user('user_with_tasks').person
     c.add_admin(p)
@@ -505,7 +506,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'refuse join community' do
     p = create_user('test_user').person
-    c = Community.create!(:name => 'Test community', :identifier => 'test_community')
+    c = fast_create(Community)
  
     assert p.ask_to_join?(c)
     p.refuse_join(c)
@@ -514,7 +515,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'not ask to join for a member' do
     p = create_user('test_user').person
-    c = Community.create!(:name => 'Test community', :identifier => 'test_community')
+    c = fast_create(Community)
     c.add_member(p)
  
     assert !p.ask_to_join?(c)
@@ -522,7 +523,7 @@ class PersonTest &lt; Test::Unit::TestCase
  
   should 'not ask to join if already asked' do
     p = create_user('test_user').person
-    c = Community.create!(:name => 'Test community', :identifier => 'test_community')
+    c = fast_create(Community)
     AddMember.create!(:person => p, :organization => c)
  
     assert !p.ask_to_join?(c)
@@ -24,7 +24,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
     person2 = create_user('testperson2').person
     person3 = create_user('testperson3').person
  
-    owner = Environment.create!(:name => 'test env')
+    owner = fast_create(Environment)
+    owner.boxes << Box.new
     block = ProfileListBlock.new
     owner.boxes.first.blocks << block
     block.save!
@@ -43,7 +44,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'list private profiles' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     profile1 = fast_create(Profile, :environment_id => env.id)
     profile2 = fast_create(Profile, :environment_id => env.id, :public_profile => false) # private profile
     block = ProfileListBlock.new
@@ -56,7 +58,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'not list invisible profiles' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     profile1 = fast_create(Profile, :environment_id => env.id)
     profile2 = fast_create(Profile, :environment_id => env.id, :visible => false) # not visible profile
     block = ProfileListBlock.new
@@ -81,7 +84,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'provide view_title' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     block = ProfileListBlock.new(:title => 'Title from block')
     env.boxes.first.blocks << block
     block.save!
@@ -89,7 +93,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'provide view title with variables' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     block = ProfileListBlock.new(:title => '{#} members')
     env.boxes.first.blocks << block
     block.save!
@@ -97,7 +102,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'count number of public and private profiles' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     block = ProfileListBlock.new
     env.boxes.first.blocks << block
     block.save!
@@ -115,7 +121,8 @@ class ProfileListBlockTest &lt; Test::Unit::TestCase
   end
  
   should 'only count number of visible profiles' do
-    env = Environment.create!(:name => 'test env')
+    env = fast_create(Environment)
+    env.boxes << Box.new
     block = ProfileListBlock.new
     env.boxes.first.blocks << block
     block.save!
@@ -4,12 +4,11 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
  
   def setup
     @profile = create_user('test_user').person
-    @article = @profile.articles.create!(:name => 'test_article', :body => 'some trivial body')
+    @article = fast_create(Article, :profile_id => @profile.id, :name => 'test_article', :body => 'some trivial body')
   end
  
-  
   should 'have a reference article and profile' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     p = PublishedArticle.create(:reference_article => @article, :profile => prof)
  
     assert p
@@ -18,7 +17,7 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'have a different name than reference article' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     p = PublishedArticle.create(:reference_article => @article, :profile => prof, :name => 'other title')
  
     assert_equal 'other title', p.name
@@ -27,7 +26,7 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'use name of reference article a default name' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof)
  
     assert_equal @article.name, p.name
@@ -37,7 +36,7 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
     parent = mock
     @article.expects(:parent).returns(parent)
     parent.expects(:blog?).returns(true)
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof)
  
     assert !prof.has_blog?
@@ -48,7 +47,7 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
     parent = mock
     @article.expects(:parent).returns(parent)
     parent.expects(:blog?).returns(true)
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     prof.articles << Blog.new(:profile => prof, :name => 'Blog test')
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof)
  
@@ -59,8 +58,8 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
     parent = mock
     @article.expects(:parent).returns(parent)
     parent.expects(:blog?).returns(false)
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
-    blog = Blog.create!(:profile => prof, :name => 'Blog test')
+    prof = fast_create(Community)
+    blog = fast_create(Blog, :profile_id => prof.id, :name => 'Blog test')
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof)
  
     assert_nil p.parent
@@ -78,8 +77,8 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'have parent if defined' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
-    folder = Folder.create(:name => 'folder test', :profile => prof)
+    prof = fast_create(Community)
+    folder = fast_create(Folder, :name => 'folder test', :profile_id => prof.id)
     p = PublishedArticle.create(:reference_article => @article, :profile => prof, :parent => folder)
  
     assert p
@@ -87,23 +86,23 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
   end
  
   should 'use to_html from reference_article' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof)
  
     assert_equal @article.to_html, p.to_html
   end
  
   should 'use to_html from reference_article when is Textile' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
-    textile_article = TextileArticle.new(:name => 'textile_article', :body => '*my text*', :profile => prof)
+    prof = fast_create(Community)
+    textile_article = fast_create(TextileArticle, :name => 'textile_article', :body => '*my text*', :profile_id => prof.id)
     p = PublishedArticle.create!(:reference_article => textile_article, :profile => prof)
  
     assert_equal textile_article.to_html, p.to_html
   end
  
   should 'display message when reference_article does not exist' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
-    textile_article = TextileArticle.new(:name => 'textile_article', :body => '*my text*', :profile => prof)
+    prof = fast_create(Community)
+    textile_article = fast_create(TextileArticle, :name => 'textile_article', :body => '*my text*', :profile_id => prof.id)
     p = PublishedArticle.create!(:reference_article => textile_article, :profile => prof)
     textile_article.destroy
     p.reload
@@ -115,17 +114,17 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
     parent = mock
     @article.stubs(:parent).returns(parent)
     parent.stubs(:blog?).returns(true)
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
+    prof = fast_create(Community)
     prof.articles << Blog.new(:profile => prof, :name => 'Blog test')
-    new_parent = Folder.create!(:profile => prof, :name => 'Folder test')
+    new_parent = fast_create(Folder, :profile_id => prof.id, :name => 'Folder test')
     p = PublishedArticle.create!(:reference_article => @article, :profile => prof, :parent => new_parent)
  
     assert_equal p.parent, new_parent
   end
  
  should 'provide first paragraph of HTML version' do
-    prof = Community.create!(:name => 'test_comm', :identifier => 'test_comm')
-    a = Article.create!(:name => 'my article', :profile_id => prof.id)
+    prof = fast_create(Community)
+    a = fast_create(Article, :name => 'my article', :profile_id => prof.id)
     a.expects(:body).returns('<p>the first paragraph of the article</p> The second paragraph')
     p = PublishedArticle.create(:reference_article => a, :profile => prof)
     assert_equal '<p>the first paragraph of the article</p>', p.first_paragraph
@@ -17,8 +17,8 @@ class RegionTest &lt; Test::Unit::TestCase
   end
  
   should 'be able to search for possible validators by name' do
-    env = Environment.create!(:name => "my test environment")
-    region = Region.create!(:environment_id => env.id, :name => 'My Region')
+    env = fast_create(Environment)
+    region = fast_create(Region, :environment_id => env.id, :name => 'My Region')
     org1 = Organization.create!(:name => 'Organization 1', :identifier => 'org1', :environment_id => env.id)
     org2 = Organization.create!(:name => 'Organization 2', :identifier => 'org2', :environment_id => env.id)
  
@@ -29,10 +29,10 @@ class RegionTest &lt; Test::Unit::TestCase
   end
  
   should 'return search results without validators that are already associated to the current region' do
-    env = Environment.create!(:name => "my test environment")
-    region = Region.create!(:environment_id => env.id, :name => 'My Region')
-    org1 = Organization.create!(:name => 'Organization 1', :identifier => 'org1', :environment_id => env.id)
-    org2 = Organization.create!(:name => 'Organization 2', :identifier => 'org2', :environment_id => env.id)
+    env = fast_create(Environment)
+    region = fast_create(Region, :environment_id => env.id, :name => 'My Region')
+    org1 = fast_create(Organization, :name => 'Organization 1', :identifier => 'org1', :environment_id => env.id)
+    org2 = fast_create(Organization, :name => 'Organization 2', :identifier => 'org2', :environment_id => env.id)
     region.validators << org1
  
     possible = region.search_possible_validators('organization')
@@ -41,15 +41,15 @@ class RegionTest &lt; Test::Unit::TestCase
   end
  
   should 'has validator' do
-    env = Environment.create!(:name => "my test environment")
-    region = Region.create!(:environment_id => env.id, :name => 'My Region')
+    env = fast_create(Environment)
+    region = fast_create(Region, :environment_id => env.id, :name => 'My Region')
     region.validators.create!(:name => 'Validator entity', :identifier => 'validator-entity')
     assert region.has_validator?
   end
  
   should 'has no validator' do
-    env = Environment.create!(:name => "my test environment")
-    region = Region.create!(:environment_id => env.id, :name => 'My Region')
+    env = fast_create(Environment)
+    region = fast_create(Region, :environment_id => env.id, :name => 'My Region')
     assert !region.has_validator?
   end
  
@@ -94,7 +94,7 @@ class RssFeedTest &lt; Test::Unit::TestCase
     blog = Blog.create!(:name => 'blog-test', :profile => profile)
     posts = []
     6.times do |i|
-      posts << TextArticle.create!(:name => "post #{i}", :profile => profile, :parent => blog)
+      posts << fast_create(TextArticle, :name => "post #{i}", :profile_id => profile.id, :parent_id => blog.id)
     end
     feed = blog.feed
     feed.limit = 5
@@ -108,7 +108,7 @@ class RssFeedTest &lt; Test::Unit::TestCase
     blog = Blog.create!(:name => 'blog-test', :profile => profile)
     posts = []
     5.times do |i|
-      posts << TextArticle.create!(:name => "post #{i}", :profile => profile, :parent => blog)
+      posts << fast_create(TextArticle, :name => "post #{i}", :profile_id => profile.id, :parent_id => blog.id)
     end
     posts[0].published = false
     posts[0].save!
@@ -10,7 +10,7 @@ class TextArticleTest &lt; Test::Unit::TestCase
  
   should 'found TextileArticle by TextArticle class' do
     person = create_user('testuser').person
-    article = TextileArticle.create!(:name => 'textile article test', :profile => person)
+    article = fast_create(TextileArticle, :name => 'textile article test', :profile_id => person.id)
     assert_includes TextArticle.find(:all), article
   end
  
@@ -87,7 +87,7 @@ class UploadedFileTest &lt; Test::Unit::TestCase
  
   should 'create icon when created in folder' do
     p = create_user('test_user').person
-    f = Folder.create!(:name => 'test_folder', :profile => p)
+    f = fast_create(Folder, :name => 'test_folder', :profile_id => p.id)
     file = UploadedFile.create!(:uploaded_data => fixture_file_upload('/files/rails.png', 'image/png'), :parent_id => f.id, :profile => p)
  
     assert File.exists?(file.public_filename(:icon))
@@ -153,7 +153,7 @@ class UserTest &lt; Test::Unit::TestCase
   end
  
   should 'set the same environment for user and person objects' do
-    env = Environment.create!(:name => 'my test environment')
+    env = fast_create(Environment)
     user = new_user(:environment_id => env.id)
     assert_equal env, user.environment
     assert_equal env, user.person.environment
...	...	@@ -220,6 +220,11 @@ module Noosfero::Factory
220	220	{ :name => name, :slug => name.to_slug, :path => name.to_slug }
221	221	end
222	222
	223	+ alias :defaults_for_text_article :defaults_for_article
	224	+ alias :defaults_for_textile_article :defaults_for_article
	225	+ alias :defaults_for_tiny_mce_article :defaults_for_article
	226	+ alias :defaults_for_rss_feed :defaults_for_article
	227	+
223	228	###############################################
224	229	# Folder
225	230	###############################################
...	...	@@ -249,7 +254,8 @@ module Noosfero::Factory
249	254	# Blog
250	255	###############################################
251	256	def defaults_for_blog
252		- { :name => 'My blog ' + factory_num_seq.to_s }
	257	+ name = 'My blog ' + factory_num_seq.to_s
	258	+ { :name => name, :slug => name.to_slug }
253	259	end
254	260
255	261	def create_blog
...	...	@@ -289,12 +295,11 @@ module Noosfero::Factory
289	295	# Category
290	296	###############################################
291	297	def defaults_for_category
292		- { :environment_id => Environment.default.id, :name => 'category' + factory_num_seq.to_s }
	298	+ name = 'category' + factory_num_seq.to_s
	299	+ { :environment_id => 1, :name => name, :slug => name.to_slug, :path => name.to_slug }
293	300	end
294	301
295		- def defaults_for_region
296		- defaults_for_category
297		- end
	302	+ alias :defaults_for_region :defaults_for_category
298	303
299	304	###############################################
300	305	# Box
...	...	@@ -303,4 +308,23 @@ module Noosfero::Factory
303	308	{ }
304	309	end
305	310
	311	+ ###############################################
	312	+ # Block
	313	+ ###############################################
	314	+ def defaults_for_block
	315	+ { }
	316	+ end
	317	+
	318	+ ###############################################
	319	+ # Task
	320	+ ###############################################
	321	+ def defaults_for_task
	322	+ { :code => "task_for_test_#{factory_num_seq.to_s}" }
	323	+ end
	324	+
	325	+ alias :defaults_for_add_friend :defaults_for_task
	326	+ alias :defaults_for_add_member :defaults_for_task
	327	+ alias :defaults_for_create_community :defaults_for_task
	328	+ alias :defaults_for_email_activation :defaults_for_task
	329	+
306	330	end
...	...
...	...	@@ -75,9 +75,9 @@ class ActsAsFilesystemTest < Test::Unit::TestCase
75	75
76	76	should 'be able to list text articles that are children of a folder' do
77	77	profile = create_user('testinguser').person
78		- folder = Folder.create!(:name => 'folder', :profile => profile)
79		- article1 = Article.create(:name => 'article 1', :profile => profile, :parent => folder)
80		- article2 = Article.create(:name => 'article 2', :profile => profile, :parent => folder)
	78	+ folder = fast_create(Folder, :name => 'folder', :profile_id => profile.id)
	79	+ article1 = Article.create!(:name => 'article 1', :profile => profile, :parent => folder)
	80	+ article2 = Article.create!(:name => 'article 2', :profile => profile, :parent => folder)
81	81	folder.reload
82	82
83	83	assert_equal [folder, article1, article2], folder.map_traversal
...	...
...	...	@@ -1,16 +0,0 @@
1		-require File.dirname(__FILE__) + '/../test_helper'
2		-
3		-class ActsAsHavingBoxesTest < Test::Unit::TestCase
4		-
5		- should 'be able to find blocks by id' do
6		- env = Environment.create!(:name => 'my test environment')
7		- env.boxes.destroy_all
8		-
9		- env.boxes << Box.new
10		- block = Block.new
11		- env.boxes.first.blocks << block
12		-
13		- assert_equal block, env.blocks.find(block.id)
14		- end
15		-
16		-end
...	...	@@ -0,0 +1,15 @@
	1	+require File.dirname(__FILE__) + '/../test_helper'
	2	+
	3	+class ActsAsHavingBoxesTest < Test::Unit::TestCase
	4	+
	5	+ should 'be able to find blocks by id' do
	6	+ env = fast_create(Environment, :name => 'An environment without blocks')
	7	+
	8	+ env.boxes << Box.new
	9	+ block = Block.new
	10	+ env.boxes.first.blocks << block
	11	+
	12	+ assert_equal block, env.blocks.find(block.id)
	13	+ end
	14	+
	15	+end
...	...
...	...	@@ -10,7 +10,7 @@ class AddFriendTest < ActiveSupport::TestCase
10	10	p1 = create_user('testuser1').person
11	11	p2 = create_user('testuser2').person
12	12
13		- task = AddFriend.create!(:person => p1, :friend => p2)
	13	+ task = fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id, :target_type => 'Person')
14	14
15	15	assert_difference Friendship, :count, 2 do
16	16	task.finish
...	...	@@ -26,7 +26,10 @@ class AddFriendTest < ActiveSupport::TestCase
26	26	p1 = create_user('testuser1').person
27	27	p2 = create_user('testuser2').person
28	28
29		- task = AddFriend.create!(:person => p1, :group_for_person => 'friend1', :friend => p2, :group_for_friend => 'friend2')
	29	+ task = fast_create(AddFriend, :requestor_id => p1, :target_id => p2.id, :target_type => 'Person')
	30	+ task.group_for_person = 'friend1'
	31	+ task.group_for_friend = 'friend2'
	32	+ assert task.save
30	33
31	34	assert_difference Friendship, :count, 2 do
32	35	task.finish
...	...	@@ -72,7 +75,7 @@ class AddFriendTest < ActiveSupport::TestCase
72	75	p1 = create_user('testuser1').person
73	76	p2 = create_user('testuser2').person
74	77
75		- task = AddFriend.create!(:person => p1, :friend => p2)
	78	+ task = fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id)
76	79
77	80	assert_equal 'testuser1 wants to be your friend.', task.description
78	81	end
...	...	@@ -85,7 +88,7 @@ class AddFriendTest < ActiveSupport::TestCase
85	88	should 'not add friend twice' do
86	89	p1 = create_user('testuser1').person
87	90	p2 = create_user('testuser2').person
88		- AddFriend.create!(:person => p1, :friend => p2)
	91	+ fast_create(AddFriend, :requestor_id => p1.id, :target_id => p2.id)
89	92	assert_raise ActiveRecord::RecordInvalid do
90	93	AddFriend.create!(:person => p1, :friend => p2)
91	94	end
...	...
...	...	@@ -8,9 +8,10 @@ class AddMemberTest < ActiveSupport::TestCase
8	8
9	9	should 'actually add memberships when confirmed' do
10	10	p = create_user('testuser1').person
11		- c = Community.create!(:name => 'closed community', :closed => true)
	11	+ c = fast_create(Community, :name => 'closed community')
	12	+ c.update_attribute(:closed, true)
12	13	TaskMailer.stubs(:deliver_target_notification)
13		- task = AddMember.create!(:person => p, :organization => c)
	14	+ task = fast_create(AddMember, :requestor_id => p.id, :target_id => c.id, :target_type => 'Community')
14	15	assert_difference c, :members, [p] do
15	16	task.finish
16	17	c.reload
...	...	@@ -41,7 +42,8 @@ class AddMemberTest < ActiveSupport::TestCase
41	42
42	43	should 'send e-mails' do
43	44	p = create_user('testuser1').person
44		- c = Community.create!(:name => 'closed community', :closed => true)
	45	+ c = fast_create(Community, :name => 'closed community')
	46	+ c.update_attribute(:closed, true)
45	47
46	48	TaskMailer.expects(:deliver_target_notification).at_least_once
47	49
...	...	@@ -50,11 +52,12 @@ class AddMemberTest < ActiveSupport::TestCase
50	52
51	53	should 'provide proper description' do
52	54	p = create_user('testuser1').person
53		- c = Community.create!(:name => 'closed community', :closed => true)
	55	+ c = fast_create(Community, :name => 'closed community')
	56	+ c.update_attribute(:closed, true)
54	57
55	58	TaskMailer.stubs(:deliver_target_notification)
56	59
57		- task = AddMember.create!(:person => p, :organization => c)
	60	+ task = fast_create(AddMember, :requestor_id => p.id, :target_id => c.id, :target_type => 'Community')
58	61
59	62	assert_equal 'testuser1 wants to be a member of "closed community".', task.description
60	63	end
...	...	@@ -66,7 +69,7 @@ class AddMemberTest < ActiveSupport::TestCase
66	69
67	70	should 'have roles' do
68	71	p = create_user('testuser1').person
69		- c = Community.create!(:name => 'community_test')
	72	+ c = fast_create(Community, :name => 'community_test')
70	73	TaskMailer.stubs(:deliver_target_notification)
71	74	task = AddMember.create!(:roles => [1,2,3], :person => p, :organization => c)
72	75	assert_equal [1,2,3], task.roles
...	...	@@ -74,7 +77,7 @@ class AddMemberTest < ActiveSupport::TestCase
74	77
75	78	should 'put member with the right roles' do
76	79	p = create_user('testuser1').person
77		- c = Community.create!(:name => 'community_test')
	80	+ c = fast_create(Community, :name => 'community_test')
78	81
79	82	roles = [Profile::Roles.member(c.environment.id), Profile::Roles.admin(c.environment.id)]
80	83	TaskMailer.stubs(:deliver_target_notification)
...	...	@@ -97,7 +100,7 @@ class AddMemberTest < ActiveSupport::TestCase
97	100
98	101	should 'ignore roles with id zero' do
99	102	p = create_user('testuser1').person
100		- c = Community.create!(:name => 'community_test')
	103	+ c = fast_create(Community, :name => 'community_test')
101	104
102	105	role = Profile::Roles.member(c.environment.id)
103	106	TaskMailer.stubs(:deliver_target_notification)
...	...
...	...	@@ -98,36 +98,11 @@ class ApplicationHelperTest < Test::Unit::TestCase
98	98
99	99	should 'rolename for' do
100	100	person = create_user('usertest').person
101		- community = Community.create!(:name => 'new community', :identifier => 'new-community', :environment => Environment.default)
	101	+ community = fast_create(Community, :name => 'new community', :identifier => 'new-community', :environment_id => Environment.default.id)
102	102	community.add_member(person)
103	103	assert_equal 'Profile Member', rolename_for(person, community)
104	104	end
105	105
106		- should 'display categories' do
107		- # FIXME implement this test!!!
108		- assert true
109		- #category = Category.create!(:name => 'parent category for testing', :environment_id => Environment.default)
110		- #child = Category.create!(:name => 'child category for testing', :environment => Environment.default, :display_in_menu => true, :parent => category)
111		- #owner = create_user('testuser').person
112		- #@article = owner.articles.create!(:name => 'ytest')
113		- #@article.add_category(category)
114		- #expects(:environment).returns(Environment.default)
115		- #result = select_categories(:article)
116		- #assert_match /parent category/, result
117		- end
118		-
119		- should 'not display categories if has no child' do
120		- # FIXME implement this test!!!
121		- assert true
122		- #category = Category.create!(:name => 'parent category for testing', :environment_id => Environment.default)
123		- #owner = create_user('testuser').person
124		- #@article = owner.articles.create!(:name => 'ytest')
125		- #@article.add_category(category)
126		- #expects(:environment).returns(Environment.default)
127		- #result = select_categories(:article)
128		- #assert_no_match /parent category/, result
129		- end
130		-
131	106	should 'get theme from environment by default' do
132	107	@environment = mock
133	108	@environment.stubs(:theme).returns('my-environment-theme')
...	...	@@ -229,7 +204,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
229	204	end
230	205
231	206	should 'return nil if disable_categories is enabled' do
232		- env = Environment.create!(:name => 'env test')
	207	+ env = fast_create(Environment, :name => 'env test')
233	208	stubs(:environment).returns(env)
234	209	assert_not_nil env
235	210	env.enable(:disable_categories)
...	...	@@ -263,14 +238,14 @@ class ApplicationHelperTest < Test::Unit::TestCase
263	238	end
264	239
265	240	should 'not draw sex icon when disabled in the environment' do
266		- env = Environment.create!(:name => 'env test')
	241	+ env = fast_create(Environment, :name => 'env test')
267	242	env.expects(:enabled?).with('disable_gender_icon').returns(true)
268	243	stubs(:environment).returns(env)
269	244	assert_equal '', profile_sex_icon(Person.new(:sex => 'male'))
270	245	end
271	246
272	247	should 'display field on signup' do
273		- env = Environment.create!(:name => 'env test')
	248	+ env = fast_create(Environment, :name => 'env test')
274	249	stubs(:environment).returns(env)
275	250
276	251	controller = mock
...	...	@@ -283,7 +258,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
283	258	end
284	259
285	260	should 'not display field on signup' do
286		- env = Environment.create!(:name => 'env test')
	261	+ env = fast_create(Environment, :name => 'env test')
287	262	stubs(:environment).returns(env)
288	263
289	264	controller = mock
...	...	@@ -296,7 +271,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
296	271	end
297	272
298	273	should 'display active fields' do
299		- env = Environment.create!(:name => 'env test')
	274	+ env = fast_create(Environment, :name => 'env test')
300	275	stubs(:environment).returns(env)
301	276
302	277	controller = mock
...	...	@@ -309,7 +284,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
309	284	end
310	285
311	286	should 'not display active fields' do
312		- env = Environment.create!(:name => 'env test')
	287	+ env = fast_create(Environment, :name => 'env test')
313	288	stubs(:environment).returns(env)
314	289
315	290	controller = mock
...	...	@@ -322,7 +297,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
322	297	end
323	298
324	299	should 'display required fields' do
325		- env = Environment.create!(:name => 'env test')
	300	+ env = fast_create(Environment, :name => 'env test')
326	301	stubs(:environment).returns(env)
327	302
328	303	controller = mock
...	...	@@ -380,7 +355,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
380	355	e.stubs(:enabled?).with(:join_community_popup).returns(true)
381	356	stubs(:environment).returns(e)
382	357
383		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	358	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
384	359	stubs(:profile).returns(c)
385	360	stubs(:logged_in?).returns(false)
386	361	assert ! ask_to_join?
...	...	@@ -393,7 +368,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
393	368	e.stubs(:enabled?).with(:join_community_popup).returns(true)
394	369	stubs(:environment).returns(e)
395	370
396		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	371	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
397	372	stubs(:profile).returns(c)
398	373	stubs(:logged_in?).returns(false)
399	374	assert ask_to_join?
...	...	@@ -406,7 +381,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
406	381	e.stubs(:enabled?).with(:join_community_popup).returns(true)
407	382	stubs(:environment).returns(e)
408	383
409		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	384	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
410	385	stubs(:profile).returns(c)
411	386	stubs(:logged_in?).returns(true)
412	387	p = create_user('test_user').person
...	...	@@ -422,7 +397,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
422	397	e = Environment.default
423	398	e.stubs(:enabled?).with(:join_community_popup).returns(true)
424	399	stubs(:environment).returns(e)
425		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	400	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
426	401	stubs(:profile).returns(c)
427	402	stubs(:logged_in?).returns(true)
428	403	p = create_user('test_user').person
...	...	@@ -438,7 +413,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
438	413	e = Environment.default
439	414	e.stubs(:enabled?).with(:join_community_popup).returns(false)
440	415	stubs(:environment).returns(e)
441		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	416	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
442	417	stubs(:profile).returns(c)
443	418	stubs(:logged_in?).returns(false)
444	419	assert !ask_to_join?
...	...	@@ -450,7 +425,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
450	425	e = Environment.default
451	426	e.stubs(:enabled?).with(:join_community_popup).returns(false)
452	427	stubs(:environment).returns(e)
453		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	428	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
454	429	stubs(:profile).returns(c)
455	430	stubs(:logged_in?).returns(true)
456	431	p = create_user('test_user').person
...	...	@@ -467,7 +442,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
467	442	e.stubs(:enabled?).with(:join_community_popup).returns(true)
468	443	stubs(:environment).returns(e)
469	444
470		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	445	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
471	446	stubs(:profile).returns(c)
472	447	stubs(:logged_in?).returns(false)
473	448	stubs(:session).returns({:no_asking => [c.id]})
...	...	@@ -482,7 +457,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
482	457	e.stubs(:enabled?).with(:join_community_popup).returns(true)
483	458	stubs(:environment).returns(e)
484	459
485		- c = Community.create(:name => 'test_comm', :identifier => 'test_comm')
	460	+ c = fast_create(Community, :name => 'test_comm', :identifier => 'test_comm')
486	461	stubs(:profile).returns(c)
487	462	stubs(:logged_in?).returns(true)
488	463	stubs(:session).returns({:no_asking => [c.id]})
...	...	@@ -507,7 +482,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
507	482	should 'display name on page title if profile doesnt have nickname' do
508	483	stubs(:environment).returns(Environment.default)
509	484
510		- c = Community.create(:name => 'Comm name', :identifier => 'test_comm')
	485	+ c = fast_create(Community, :name => 'Comm name', :identifier => 'test_comm')
511	486	stubs(:profile).returns(c)
512	487	assert_match(/Comm name/, page_title)
513	488	end
...	...	@@ -515,7 +490,7 @@ class ApplicationHelperTest < Test::Unit::TestCase
515	490	should 'display nickname on page title if profile has nickname' do
516	491	stubs(:environment).returns(Environment.default)
517	492
518		- c = Community.create(:name => 'Community for tests', :nickname => 'Community nickname', :identifier => 'test_comm')
	493	+ c = fast_create(Community, :name => 'Community for tests', :nickname => 'Community nickname', :identifier => 'test_comm')
519	494	stubs(:profile).returns(c)
520	495	assert_match(/Community nickname/, page_title)
521	496	end
...	...
...	...	@@ -11,7 +11,7 @@ class ApproveArticleTest < ActiveSupport::TestCase
11	11	attr_reader :profile
12	12
13	13	should 'have name, reference article and profile' do
14		- article = profile.articles.create!(:name => 'test article')
	14	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
15	15
16	16	a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
17	17
...	...	@@ -21,7 +21,7 @@ class ApproveArticleTest < ActiveSupport::TestCase
21	21	end
22	22
23	23	should 'create published article when finished' do
24		- article = profile.articles.create!(:name => 'test article')
	24	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
25	25	a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
26	26
27	27	assert_difference PublishedArticle, :count do
...	...	@@ -39,7 +39,7 @@ class ApproveArticleTest < ActiveSupport::TestCase
39	39	end
40	40
41	41	should 'have parent if defined' do
42		- article = profile.articles.create!(:name => 'test article')
	42	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
43	43	folder = profile.articles.create!(:name => 'test folder', :type => 'Folder')
44	44
45	45	a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile, :article_parent_id => folder.id)
...	...	@@ -48,7 +48,7 @@ class ApproveArticleTest < ActiveSupport::TestCase
48	48	end
49	49
50	50	should 'not have parent if not defined' do
51		- article = profile.articles.create!(:name => 'test article')
	51	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
52	52
53	53	a = ApproveArticle.create!(:name => 'test name', :article => article, :target => profile, :requestor => profile)
54	54
...	...	@@ -75,7 +75,7 @@ class ApproveArticleTest < ActiveSupport::TestCase
75	75
76	76	should 'handle blank names' do
77	77	article = profile.articles.create!(:name => 'test article')
78		- community = Community.create!(:name => 'test comm')
	78	+ community = fast_create(Community, :name => 'test comm')
79	79	a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
80	80
81	81	assert_difference PublishedArticle, :count do
...	...	@@ -84,14 +84,14 @@ class ApproveArticleTest < ActiveSupport::TestCase
84	84	end
85	85
86	86	should 'notify target if group is moderated' do
87		- article = profile.articles.create!(:name => 'test article')
	87	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
88	88	community = Community.create!(:name => 'test comm', :moderated_articles => true)
89	89	a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
90	90	assert !ActionMailer::Base.deliveries.empty?
91	91	end
92	92
93	93	should 'not notify target if group is not moderated' do
94		- article = profile.articles.create!(:name => 'test article')
	94	+ article = fast_create(TextArticle, :profile_id => profile.id, :name => 'test article')
95	95	community = Community.create!(:name => 'test comm', :moderated_articles => false)
96	96	a = ApproveArticle.create!(:name => '', :article => article, :target => community, :requestor => profile)
97	97	assert ActionMailer::Base.deliveries.empty?
...	...
...	...	@@ -71,7 +71,7 @@ class ArticleBlockTest < Test::Unit::TestCase
71	71	env.articles.destroy_all
72	72	assert_equal [], env.articles
73	73	community = fast_create(Community)
74		- a = community.articles.create!(:name => 'test')
	74	+ a = fast_create(TextArticle, :profile_id => community.id, :name => 'test')
75	75	env.portal_community=community
76	76	env.save
77	77	block = ArticleBlock.create(:article => a)
...	...
...	...	@@ -76,7 +76,7 @@ class ArticleTest < Test::Unit::TestCase
76	76
77	77	should 'provide HTML version' do
78	78	profile = create_user('testinguser').person
79		- a = Article.create!(:name => 'my article', :profile_id => profile.id)
	79	+ a = fast_create(Article, :name => 'my article', :profile_id => profile.id)
80	80	a.expects(:body).returns('the body of the article')
81	81	assert_equal 'the body of the article', a.to_html
82	82	end
...	...	@@ -88,7 +88,7 @@ class ArticleTest < Test::Unit::TestCase
88	88
89	89	should 'provide first paragraph of HTML version' do
90	90	profile = create_user('testinguser').person
91		- a = Article.create!(:name => 'my article', :profile_id => profile.id)
	91	+ a = fast_create(Article, :name => 'my article', :profile_id => profile.id)
92	92	a.expects(:body).returns('<p>the first paragraph of the article</p> The second paragraph')
93	93	assert_equal '<p>the first paragraph of the article</p>', a.first_paragraph
94	94	end
...	...	@@ -149,11 +149,11 @@ class ArticleTest < Test::Unit::TestCase
149	149
150	150	Article.destroy_all
151	151
152		- first = profile.articles.build(:name => 'first'); first.save!
153		- second = profile.articles.build(:name => 'second'); second.save!
154		- third = profile.articles.build(:name => 'third'); third.save!
155		- fourth = profile.articles.build(:name => 'fourth'); fourth.save!
156		- fifth = profile.articles.build(:name => 'fifth'); fifth.save!
	152	+ first = fast_create(TextArticle, :profile_id => profile.id, :name => 'first')
	153	+ second = fast_create(TextArticle, :profile_id => profile.id, :name => 'second')
	154	+ third = fast_create(TextArticle, :profile_id => profile.id, :name => 'third')
	155	+ fourth = fast_create(TextArticle, :profile_id => profile.id, :name => 'fourth')
	156	+ fifth = fast_create(TextArticle, :profile_id => profile.id, :name => 'fifth')
157	157
158	158	other_first = other_profile.articles.build(:name => 'first'); other_first.save!
159	159
...	...	@@ -165,8 +165,8 @@ class ArticleTest < Test::Unit::TestCase
165	165	p = create_user('usr1').person
166	166	Article.destroy_all
167	167
168		- first = p.articles.build(:name => 'first', :published => true); first.save!
169		- second = p.articles.build(:name => 'second', :published => false); second.save!
	168	+ first = fast_create(TextArticle, :profile_id => p.id, :name => 'first', :published => true)
	169	+ second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
170	170
171	171	assert_equal [ first ], Article.recent(nil)
172	172	end
...	...	@@ -175,8 +175,8 @@ class ArticleTest < Test::Unit::TestCase
175	175	p = create_user('usr1').person
176	176	Article.destroy_all
177	177
178		- first = p.articles.build(:name => 'first', :published => true); first.save!
179		- second = p.articles.build(:name => 'second', :published => false); second.save!
	178	+ first = fast_create(TextArticle, :profile_id => p.id, :name => 'first', :published => true)
	179	+ second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
180	180
181	181	assert_equal [ first ], Article.recent(nil)
182	182	end
...	...	@@ -185,8 +185,8 @@ class ArticleTest < Test::Unit::TestCase
185	185	p = fast_create(Person, :public_profile => false)
186	186	Article.destroy_all
187	187
188		- first = p.articles.build(:name => 'first', :published => true); first.save!
189		- second = p.articles.build(:name => 'second', :published => false); second.save!
	188	+ first = fast_create(TextArticle, :profile_id => p.id, :name => 'first', :published => true)
	189	+ second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
190	190
191	191	assert_equal [ ], Article.recent(nil)
192	192	end
...	...	@@ -195,8 +195,8 @@ class ArticleTest < Test::Unit::TestCase
195	195	p = fast_create(Person, :visible => false)
196	196	Article.destroy_all
197	197
198		- first = p.articles.build(:name => 'first', :published => true); first.save!
199		- second = p.articles.build(:name => 'second', :published => false); second.save!
	198	+ first = fast_create(TextArticle, :profile_id => p.id, :name => 'first', :published => true)
	199	+ second = fast_create(TextArticle, :profile_id => p.id, :name => 'second', :published => false)
200	200
201	201	assert_equal [ ], Article.recent(nil)
202	202	end
...	...	@@ -224,7 +224,7 @@ class ArticleTest < Test::Unit::TestCase
224	224	Article.destroy_all
225	225
226	226	first = UploadedFile.new(:profile => p, :uploaded_data => fixture_file_upload('/files/rails.png', 'image/png')); first.save!
227		- second = p.articles.build(:name => 'second'); second.save!
	227	+ second = fast_create(TextArticle, :profile_id => p.id, :name => 'second')
228	228
229	229	assert_equal [ second ], Article.recent(nil)
230	230	end
...	...	@@ -232,7 +232,7 @@ class ArticleTest < Test::Unit::TestCase
232	232	should 'not show RssFeed as recent' do
233	233	p = create_user('usr1').person
234	234	Article.destroy_all
235		- first = RssFeed.create!(:profile => p, :name => 'my feed', :advertise => true)
	235	+ first = fast_create(RssFeed, :profile_id => p.id, :name => 'my feed', :advertise => true)
236	236	first.limit = 10; first.save!
237	237	second = p.articles.build(:name => 'second'); second.save!
238	238
...	...	@@ -242,7 +242,7 @@ class ArticleTest < Test::Unit::TestCase
242	242	should 'not show blog as recent' do
243	243	p = create_user('usr1').person
244	244	Article.destroy_all
245		- first = Blog.create!(:profile => p, :name => 'my blog', :advertise => true)
	245	+ first = fast_create(Blog, :profile_id => p.id, :name => 'my blog', :advertise => true)
246	246	second = p.articles.build(:name => 'second'); second.save!
247	247
248	248	assert_equal [ second ], Article.recent(nil)
...	...	@@ -425,8 +425,8 @@ class ArticleTest < Test::Unit::TestCase
425	425	end
426	426
427	427	should 'be able to create an article already with categories' do
428		- c1 = Category.create!(:environment => Environment.default, :name => 'c1')
429		- c2 = Category.create!(:environment => Environment.default, :name => 'c2')
	428	+ c1 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c1')
	429	+ c2 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c2')
430	430
431	431	p = create_user('testinguser').person
432	432	a = p.articles.create!(:name => 'test', :category_ids => [c1.id, c2.id])
...	...	@@ -435,7 +435,7 @@ class ArticleTest < Test::Unit::TestCase
435	435	end
436	436
437	437	should 'not add a category twice to article' do
438		- c1 = Category.create!(:environment => Environment.default, :name => 'c1')
	438	+ c1 = fast_create(Category, :environment_id => Environment.default.id, :name => 'c1')
439	439	c2 = c1.children.create!(:environment => Environment.default, :name => 'c2')
440	440	c3 = c1.children.create!(:environment => Environment.default, :name => 'c3')
441	441	owner = create_user('testuser').person
...	...	@@ -454,23 +454,23 @@ class ArticleTest < Test::Unit::TestCase
454	454	end
455	455
456	456	should 'say that logged off user cannot see private article' do
457		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
458		- article = Article.create!(:name => 'test article', :profile => profile, :published => false)
	457	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	458	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
459	459
460	460	assert !article.display_to?(nil)
461	461	end
462	462
463	463	should 'say that not member of profile cannot see private article' do
464		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
465		- article = Article.create!(:name => 'test article', :profile => profile, :published => false)
	464	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	465	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
466	466	person = create_user('test_user').person
467	467
468	468	assert !article.display_to?(person)
469	469	end
470	470
471	471	should 'say that member user can not see private article' do
472		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
473		- article = Article.create!(:name => 'test article', :profile => profile, :published => false)
	472	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	473	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
474	474	person = create_user('test_user').person
475	475	profile.affiliate(person, Profile::Roles.member(profile.environment.id))
476	476
...	...	@@ -478,8 +478,8 @@ class ArticleTest < Test::Unit::TestCase
478	478	end
479	479
480	480	should 'say that profile admin can see private article' do
481		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
482		- article = Article.create!(:name => 'test article', :profile => profile, :published => false)
	481	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	482	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
483	483	person = create_user('test_user').person
484	484	profile.affiliate(person, Profile::Roles.admin(profile.environment.id))
485	485
...	...	@@ -487,8 +487,8 @@ class ArticleTest < Test::Unit::TestCase
487	487	end
488	488
489	489	should 'say that profile moderator can see private article' do
490		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
491		- article = Article.create!(:name => 'test article', :profile => profile, :published => false)
	490	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	491	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => false)
492	492	person = create_user('test_user').person
493	493	profile.affiliate(person, Profile::Roles.moderator(profile.environment.id))
494	494
...	...	@@ -496,8 +496,8 @@ class ArticleTest < Test::Unit::TestCase
496	496	end
497	497
498	498	should 'not show article to non member if article public but profile private' do
499		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile', :public_profile => false)
500		- article = Article.create!(:name => 'test article', :profile => profile, :published => true)
	499	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile', :public_profile => false)
	500	+ article = fast_create(Article, :name => 'test article', :profile_id => profile.id, :published => true)
501	501	person1 = create_user('test_user1').person
502	502	profile.affiliate(person1, Profile::Roles.member(profile.environment.id))
503	503	person2 = create_user('test_user2').person
...	...	@@ -508,17 +508,17 @@ class ArticleTest < Test::Unit::TestCase
508	508	end
509	509
510	510	should 'make new article private if created inside a private folder' do
511		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
512		- folder = Folder.create!(:name => 'my_intranet', :profile => profile, :published => false)
513		- article = Article.create!(:name => 'my private article', :profile => profile, :parent => folder)
	511	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	512	+ folder = fast_create(Folder, :name => 'my_intranet', :profile_id => profile.id, :published => false)
	513	+ article = fast_create(Article, :name => 'my private article', :profile_id => profile.id, :parent_id => folder.id)
514	514
515	515	assert !article.published?
516	516	end
517	517
518	518	should 'save as private' do
519		- profile = Profile.create!(:name => 'test profile', :identifier => 'test_profile')
520		- folder = Folder.create!(:name => 'my_intranet', :profile => profile, :published => false)
521		- article = TextileArticle.new(:name => 'my private article')
	519	+ profile = fast_create(Profile, :name => 'test profile', :identifier => 'test_profile')
	520	+ folder = fast_create(Folder, :name => 'my_intranet', :profile_id => profile.id, :published => false)
	521	+ article = fast_create(Article, :name => 'my private article')
522	522	article.profile = profile
523	523	article.parent = folder
524	524	article.save!
...	...	@@ -540,7 +540,7 @@ class ArticleTest < Test::Unit::TestCase
540	540
541	541	should 'display private articles to people who can view private content' do
542	542	person = create_user('test_user').person
543		- article = Article.create!(:name => 'test article', :profile => person, :published => false)
	543	+ article = fast_create(Article, :name => 'test article', :profile_id => person.id, :published => false)
544	544
545	545	admin_user = create_user('admin_user').person
546	546	admin_user.stubs(:has_permission?).with('view_private_content', article.profile).returns('true')
...	...	@@ -570,7 +570,7 @@ class ArticleTest < Test::Unit::TestCase
570	570
571	571	should 'mantain the type in a copy' do
572	572	p = create_user('test_user').person
573		- a = Folder.create!(:name => 'test folder', :profile => p)
	573	+ a = fast_create(Folder, :name => 'test folder', :profile_id => p.id)
574	574	b = a.copy(:parent => a, :profile => p)
575	575
576	576	assert_kind_of Folder, b
...	...	@@ -638,15 +638,15 @@ class ArticleTest < Test::Unit::TestCase
638	638
639	639	should 'identify if belongs to blog' do
640	640	p = create_user('user_blog_test').person
641		- blog = Blog.create!(:name => 'Blog test', :profile => p)
642		- post = TextileArticle.create!(:name => 'First post', :profile => p, :parent => blog)
	641	+ blog = fast_create(Blog, :name => 'Blog test', :profile_id => p.id)
	642	+ post = fast_create(TextileArticle, :name => 'First post', :profile_id => p.id, :parent_id => blog.id)
643	643	assert post.belongs_to_blog?
644	644	end
645	645
646	646	should 'not belongs to blog' do
647	647	p = create_user('user_blog_test').person
648		- folder = Folder.create!(:name => 'Not Blog', :profile => p)
649		- a = TextileArticle.create!(:name => 'Not blog post', :profile => p, :parent => folder)
	648	+ folder = fast_create(Folder, :name => 'Not Blog', :profile_id => p.id)
	649	+ a = fast_create(TextileArticle, :name => 'Not blog post', :profile_id => p.id, :parent_id => folder.id)
650	650	assert !a.belongs_to_blog?
651	651	end
652	652
...	...	@@ -656,7 +656,7 @@ class ArticleTest < Test::Unit::TestCase
656	656	end
657	657
658	658	should 'hold hits count' do
659		- a = Article.create!(:name => 'Test article', :profile => profile)
	659	+ a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
660	660	a.hits = 10
661	661	a.save!
662	662	a.reload
...	...	@@ -664,7 +664,7 @@ class ArticleTest < Test::Unit::TestCase
664	664	end
665	665
666	666	should 'increment hit counter when hitted' do
667		- a = Article.create!(:name => 'Test article', :profile => profile, :hits => 10)
	667	+ a = fast_create(Article, :name => 'Test article', :profile_id => profile.id, :hits => 10)
668	668	a.hit
669	669	assert_equal 11, a.hits
670	670	a.reload
...	...	@@ -672,13 +672,13 @@ class ArticleTest < Test::Unit::TestCase
672	672	end
673	673
674	674	should 'have display_hits setting with default true' do
675		- a = Article.create!(:name => 'Test article', :profile => profile)
	675	+ a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
676	676	assert_respond_to a, :display_hits
677	677	assert_equal true, a.display_hits
678	678	end
679	679
680	680	should 'can display hits' do
681		- a = Article.create!(:name => 'Test article', :profile => profile)
	681	+ a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
682	682	assert_respond_to a, :can_display_hits?
683	683	assert_equal true, a.can_display_hits?
684	684	end
...	...	@@ -690,7 +690,7 @@ class ArticleTest < Test::Unit::TestCase
690	690	end
691	691
692	692	should 'not return a view url when common article' do
693		- a = Article.create!(:name => 'Test article', :profile => profile)
	693	+ a = fast_create(Article, :name => 'Test article', :profile_id => profile.id)
694	694
695	695	assert_equal a.url, a.view_url
696	696	end
...	...	@@ -708,17 +708,17 @@ class ArticleTest < Test::Unit::TestCase
708	708	end
709	709
710	710	should 'published_at is same as created_at if not set' do
711		- a = Article.create!(:name => 'Published at', :profile => profile)
	711	+ a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
712	712	assert_equal a.created_at, a.published_at
713	713	end
714	714
715	715	should 'use npage to compose cache key' do
716		- a = Article.create!(:name => 'Published at', :profile => profile)
	716	+ a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
717	717	assert_match(/-npage-2/,a.cache_key(:npage => 2))
718	718	end
719	719
720	720	should 'use year and month to compose cache key' do
721		- a = Article.create!(:name => 'Published at', :profile => profile)
	721	+ a = fast_create(Article, :name => 'Published at', :profile_id => profile.id)
722	722	assert_match(/-year-2009-month-04/, a.cache_key(:year => '2009', :month => '04'))
723	723	end
724	724
...	...	@@ -728,7 +728,7 @@ class ArticleTest < Test::Unit::TestCase
728	728	end
729	729
730	730	should 'get tagged with tag' do
731		- a = Article.create!(:name => 'Published at', :profile => profile, :tag_list => 'bli')
	731	+ a = create(Article, :name => 'Published at', :profile_id => profile.id, :tag_list => 'bli')
732	732	as = Article.find_tagged_with('bli')
733	733
734	734	assert_includes as, a
...	...	@@ -749,7 +749,7 @@ class ArticleTest < Test::Unit::TestCase
749	749
750	750	should 'ignore category with zero as id' do
751	751	a = profile.articles.create!(:name => 'a test article')
752		- c = Category.create!(:name => 'test category', :environment => profile.environment)
	752	+ c = fast_create(Category, :name => 'test category', :environment_id => profile.environment.id)
753	753	a.category_ids = ['0', c.id, nil]
754	754	assert a.save
755	755	assert_equal [c], a.categories
...	...	@@ -766,13 +766,13 @@ class ArticleTest < Test::Unit::TestCase
766	766	end
767	767
768	768	should 'add owner on cache_key when profile is community' do
769		- c = Community.create!(:name => 'new_comm')
	769	+ c = fast_create(Community)
770	770	a = c.articles.create!(:name => 'a test article')
771	771	assert_match(/-owner/, a.cache_key({}, c))
772	772	end
773	773
774	774	should 'have a creator method' do
775		- c = Community.create!(:name => 'new_comm')
	775	+ c = fast_create(Community)
776	776	a = c.articles.create!(:name => 'a test article', :last_changed_by => profile)
777	777	p = create_user('other_user').person
778	778	a.update_attributes(:body => 'some content', :last_changed_by => p); a.save!
...	...	@@ -780,7 +780,7 @@ class ArticleTest < Test::Unit::TestCase
780	780	end
781	781
782	782	should 'allow creator to edit if is publisher' do
783		- c = Community.create!(:name => 'new_comm')
	783	+ c = fast_create(Community)
784	784	p = create_user_with_permission('test_user', 'publish_content', c)
785	785	a = c.articles.create!(:name => 'a test article', :last_changed_by => p)
786	786
...	...	@@ -788,7 +788,7 @@ class ArticleTest < Test::Unit::TestCase
788	788	end
789	789
790	790	should 'allow user with "Manage content" permissions to edit' do
791		- c = Community.create!(:name => 'new_comm')
	791	+ c = fast_create(Community)
792	792	p = create_user_with_permission('test_user', 'post_content', c)
793	793	a = c.articles.create!(:name => 'a test article')
794	794
...	...	@@ -796,7 +796,7 @@ class ArticleTest < Test::Unit::TestCase
796	796	end
797	797
798	798	should 'update slug from name' do
799		- article = Article.create!(:name => 'A test article', :profile => profile)
	799	+ article = create(Article, :name => 'A test article', :profile_id => profile.id)
800	800	assert_equal 'a-test-article', article.slug
801	801	article.name = 'Changed name'
802	802	assert_equal 'changed-name', article.slug
...	...