Implmenting some improvement on profile activity:

* The users member of a community shoudl be notified with the information of where that noficication is. * The friendship relationship should be notified to the both users * If the article is created automaticaly according its template this article should not be notified * The article approval should not notify the article with the user who aproved it as the user that made the article (ActionItem1303)

Implmenting some improvement on profile activity:
* The users member of a community shoudl be notified with the information of where that noficication is. * The friendship relationship should be notified to the both users * If the article is created automaticaly according its template this article should not be notified * The article approval should not notify the article with the user who aproved it as the user that made the article (ActionItem1303)
Leandro Santos · Antonio Terceiro
1 parent fb5e9d89
Showing 28 changed files with 932 additions and 119 deletions Show diff stats
app/models/article.rb
app/models/comment.rb
app/models/friendship.rb
app/models/person.rb
app/models/published_article.rb
app/views/profile/_profile_network_activities.rhtml
config/initializers/action_tracker.rb
db/migrate/20100920182433_change_action_tracker_record.rb
lib/notify_activity_to_profiles_job.rb
test/factories.rb
test/functional/profile_controller_test.rb
test/unit/article_test.rb
test/unit/comment_test.rb
test/unit/community_test.rb
test/unit/friendship_test.rb
test/unit/notify_activity_to_profiles_job_test.rb
test/unit/person_test.rb
test/unit/published_article_test.rb
test/unit/textile_article_test.rb
test/unit/tiny_mce_article_test.rb
@@ -2,10 +2,9 @@ require &#39;hpricot&#39;
 class Article < ActiveRecord::Base
-  track_actions :create_article, :after_create, :keep_params => [:name, :url], :if => Proc.new { |a| a.published? && !a.profile.is_a?(Community) && !a.image? && a.notifiable? }
-  track_actions :update_article, :before_update, :keep_params => [:name, :url], :if => Proc.new { |a| a.published? && (a.body_changed? || a.name_changed?) && a.notifiable? }
-  track_actions :remove_article, :before_destroy, :keep_params => [:name], :if => Proc.new { |a| a.published? && a.notifiable? }
-  track_actions :publish_article_in_community, :after_create, :keep_params => ["name", "url", "profile.url", "profile.name"], :if => Proc.new { |a| a.published? && a.profile.is_a?(Community) && !a.image? && a.notifiable? }
+  track_actions :create_article, :after_create, :keep_params => [:name, :url], :if => Proc.new { |a| a.is_trackable? && !a.image? }, :custom_target => :action_tracker_target
+  track_actions :update_article, :before_update, :keep_params => [:name, :url], :if => Proc.new { |a| a.is_trackable? && (a.body_changed? || a.name_changed?) }, :custom_target => :action_tracker_target
+  track_actions :remove_article, :before_destroy, :keep_params => [:name], :if => Proc.new { |a| a.is_trackable? }, :custom_target => :action_tracker_target
   # xss_terminate plugin can't sanitize array fields
   before_save :sanitize_tag_list
@@ -43,6 +42,10 @@ class Article &lt; ActiveRecord::Base
   validates_format_of :external_link, :with => URL_FORMAT, :if => lambda { |article| !article.external_link.blank? }
+  def is_trackable?
+    self.published? && self.notifiable? && self.advertise?
+  end
+
   def external_link=(link)
     if !link.blank? && link !~ /^[a-z]+:\/\//i
       link = 'http://' + link
@@ -50,6 +53,9 @@ class Article &lt; ActiveRecord::Base
     self[:external_link] = link
   end
+  def action_tracker_target
+    self.profile
+  end
   def self.human_attribute_name(attrib)
     case attrib.to_sym
 class Comment < ActiveRecord::Base
-  track_actions :leave_comment, :after_create, :keep_params => ["article.title", "article.url", "title", "url", "body"]
+  track_actions :leave_comment, :after_create, :keep_params => ["article.title", "article.url", "title", "url", "body"], :custom_target => :action_tracker_target 
   validates_presence_of :title, :body
   belongs_to :article, :counter_cache => true
@@ -21,6 +21,10 @@ class Comment &lt; ActiveRecord::Base
   xss_terminate :only => [ :body, :title, :name ], :on => 'validation'
+  def action_tracker_target
+    self.article.profile
+  end
+
   def author_name
     if author
       author.short_name
 class Friendship < ActiveRecord::Base
-  track_actions :new_friendship, :after_create, :keep_params => ["friend.name", "friend.url", "friend.profile_custom_icon"], :unless => Proc.new { |f| f.friend.is_a_friend?(f.person) }
+  track_actions :new_friendship, :after_create, :keep_params => ["friend.name", "friend.url", "friend.profile_custom_icon"], :custom_user => :person
   belongs_to :person, :foreign_key => :person_id
   belongs_to :friend, :class_name => 'Person', :foreign_key => 'friend_id'
@@ -327,12 +327,7 @@ class Person &lt; Profile
   end
   def self.notify_activity(tracked_action)
-    profile = tracked_action.dispatcher.profile if tracked_action.dispatcher.is_a?(Article)
-    profile = tracked_action.dispatcher.resource if tracked_action.dispatcher.is_a?(RoleAssignment)
-    profile = tracked_action.dispatcher.article.profile if tracked_action.dispatcher.is_a?(Comment)
-    profile_id = profile.nil? ? nil : profile.id
-    Delayed::Job.enqueue NotifyActivityToProfilesJob.new(tracked_action.id, profile_id)
-    ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => tracked_action.user)
+    Delayed::Job.enqueue NotifyActivityToProfilesJob.new(tracked_action.id)
   end
   def is_member_of?(profile)
@@ -37,4 +37,8 @@ class PublishedArticle &lt; Article
     reference_article && reference_article.abstract
   end
+  def notifiable?
+    true
+  end
+
 end
@@ -9,6 +9,7 @@
       <div class='profile-network-description'>
         <p class='profile-network-time'><%= time_ago_as_sentence(activity.created_at) + ' ' + _('ago') %></p>
         <p class='profile-network-text'><%= link_to activity.user.name, activity.user.url %> <%= describe activity %></p>
+        <p class='profile-network-where'><%= _('In community %s') % link_to(activity.target.name, activity.target.url) if !profile.is_a?(Community) && activity.target.is_a?(Community) %></p>
       </div>
         <div id='profile-network-message-<%= activity.id%>' style='display:none;'>
         <div id='profile-network-form-<%= activity.id%>' style='display:none;'>
@@ -19,11 +19,6 @@ ActionTrackerConfig.verbs = {
     :type => :groupable
   },
-  :publish_article_in_community => {
-    :description => lambda { n_('published 1 article in communities: %{title}', 'published %{num} articles in communities: %{title}', get_name.size) % { :num => get_name.size, :title => '{{ta.collect_group_with_index(:name){ |n,i| link_to(truncate(n), ta.get_url[i]) + " (%s " + link_to(ta.get_profile_name[i], ta.get_profile_url[i]) + ")" }.to_sentence(:connector => "%s")}}' % [_("in"), _("and")] } },
-    :type => :groupable
-  },
-
   :new_friendship => { 
     :description => lambda { n_('has made 1 new friend:<br />%{name}', 'has made %{num} new friends:<br />%{name}', get_friend_name.size) % { :num => get_friend_name.size, :name => '{{ta.collect_group_with_index(:friend_name){ |n,i| link_to(content_tag(:img, nil, :src => (ta.get_friend_profile_custom_icon[i] || default_or_themed_icon("/images/icons-app/person-icon.png"))), ta.get_friend_url[i], :title => n)}.join}}' } },
     :type => :groupable
@@ -34,6 +29,14 @@ ActionTrackerConfig.verbs = {
     :type => :groupable
   },
+  :add_member_in_community => { 
+    :description => lambda { _('has joined the community.') },
+  },
+
+  :remove_member_in_community => { 
+    :description => lambda { _('has left the community.') },
+  },
+
   :leave_community => {
     :description => lambda { n_('has left 1 community:<br />%{name}', 'has left %{num} communities:<br />%{name}', get_resource_name.size) % { :num => get_resource_name.size, :name => '{{ta.collect_group_with_index(:resource_name){ |n,i| link_to(content_tag(:img, nil, :src => (ta.get_resource_profile_custom_icon[i] || default_or_themed_icon("/images/icons-app/community-icon.png"))), ta.get_resource_url[i], :title => n)}.join}}' } },
     :type => :groupable
@@ -0,0 +1,13 @@
+class ChangeActionTrackerRecord < ActiveRecord::Migration
+  def self.up
+    rename_column(:action_tracker, :dispatcher_type, :target_type)
+    rename_column(:action_tracker, :dispatcher_id, :target_id)
+    ActionTracker::Record.update_all("verb='create_article'", {:verb => 'publish_article_in_community'})
+  end
+
+  def self.down
+    raise "this migration can't be reverted"
+    rename_column(:action_tracker, :target_type, :dispatcher_type)
+    rename_column(:action_tracker, :target_id, :dispatcher_id)
+  end
+end
-class NotifyActivityToProfilesJob < Struct.new(:tracked_action_id, :target_profile_id)
+class NotifyActivityToProfilesJob < Struct.new(:tracked_action_id)
+  NOTIFY_ONLY_COMMUNITY = [
+    'add_member_in_community',
+    'remove_member_in_community',
+  ]
+
+  NOT_NOTIFY_COMMUNITY = [
+    'join_community',
+    'leave_community',
+  ]
   def perform
-    profile = Profile.find(target_profile_id) unless target_profile_id.nil?
     tracked_action = ActionTracker::Record.find(tracked_action_id)
+    target = tracked_action.target
+    if target.is_a?(Community) && NOTIFY_ONLY_COMMUNITY.include?(tracked_action.verb)
+      ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => target)
+      return
+    end
+
+    ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => tracked_action.user)
     tracked_action.user.each_friend do |friend|
       ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => friend)
     end
-    if profile.is_a?(Community)
-      profile.each_member do |member|
+
+    if target.is_a?(Community)
+      target.each_member do |member|
         next if member == tracked_action.user
         ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => member)
       end
-      ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => profile)
+      ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => target) unless NOT_NOTIFY_COMMUNITY.include?(tracked_action.verb)
     end
   end
 end
@@ -224,7 +224,7 @@ module Noosfero::Factory
   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
-  alias :defaults_for_textile_article    :defaults_for_article
+  alias :defaults_for_published_article  :defaults_for_article
   alias :defaults_for_folder             :defaults_for_article
   ###############################################
@@ -381,7 +381,7 @@ module Noosfero::Factory
   ###############################################
   def defaults_for_action_tracker_record(params = {})
-    { :created_at => DateTime.now, :verb => :leave_comment, :user_type => 'Profile', :user_id => 1 }.merge(params)
+    { :created_at => DateTime.now, :verb => 'add_member_in_community', :user_type => 'Profile', :user_id => 1 }.merge(params)
   end
   ###############################################
@@ -769,7 +769,8 @@ class ProfileControllerTest &lt; Test::Unit::TestCase
   should 'the network activity be paginated' do
     p1= Person.first
-    40.times{Scrap.create!(defaults_for_scrap(:sender => p1, :receiver => p1))}
+    at = fast_create(ActionTracker::Record)
+    40.times{fast_create(ActionTrackerNotification, :action_tracker_id => at.id, :profile_id => p1.id)}
     @controller.stubs(:logged_in?).returns(true)
     user = mock()
@@ -1020,4 +1020,40 @@ class ArticleTest &lt; Test::Unit::TestCase
     assert_equal 0, ActionTracker::Record.count
   end
+  should "the action_tracker_target method be defined" do
+    assert Article.method_defined?(:action_tracker_target)
+  end
+
+  should "the action_tracker_target method return the article profile" do
+    profile = fast_create(Person)
+    article = fast_create(Article, :profile_id => profile.id)
+    assert_equal profile, article.action_tracker_target
+
+    profile = fast_create(Community)
+    article = fast_create(Article, :profile_id => profile.id)
+    assert_equal profile, article.action_tracker_target
+  end
+
+  should "have defined the is_trackable method defined" do
+    assert Article.method_defined?(:is_trackable?)
+  end
+
+  should "the common trackable conditions return the correct value" do
+    a =  Article.new
+    a.published = a.advertise = true
+    assert_equal true, a.published?
+    assert_equal false, a.notifiable?
+    assert_equal true, a.advertise?
+    assert_equal false, a.is_trackable?
+   
+    a.published=false
+    assert_equal false, a.published?
+    assert_equal false, a.is_trackable?
+
+    a.published=true
+    a.advertise=false
+    assert_equal false, a.advertise?
+    assert_equal false, a.is_trackable?
+  end
+
 end
@@ -226,4 +226,16 @@ class CommentTest &lt; Test::Unit::TestCase
     assert_equal comment.url, ta.get_url
   end
+  should 'have the action_tracker_target defined' do
+    assert Comment.method_defined?(:action_tracker_target)
+  end
+
+  should "have the action_tracker_target be the articles's profile" do
+    owner = create_user('testuser').person
+    article = owner.articles.create!(:name => 'test', :body => '...')
+    comment = article.comments.create!(:article => article, :name => 'foo', :title => 'bar', :body => 'my comment', :email => 'cracker@test.org')
+    ta = ActionTracker::Record.last
+    assert_equal owner, ta.target
+  end
+
 end
@@ -242,9 +242,9 @@ class CommunityTest &lt; Test::Unit::TestCase
     RoleAssignment.delete_all
     ActionTrackerNotification.delete_all
-    RoleAssignment.any_instance.stubs(:role_id).returns(3)
-    assert_difference(ActionTrackerNotification, :count, 3) do
+    assert_difference(ActionTrackerNotification, :count, 5) do
       community.add_member(p1)
+      process_delayed_job_queue
       community.add_member(p3)
       assert p1.is_member_of?(community)
       assert !p2.is_member_of?(community)
@@ -23,23 +23,27 @@ class FriendshipTest &lt; Test::Unit::TestCase
   end
   should 'create tracked action' do
-    f = Friendship.create! :person => create_user('a').person, :friend => create_user('b').person
+    a, b, c = create_user('a').person, create_user('b').person, create_user('c').person
+    f = Friendship.create! :person => a, :friend => b
     ta = ActionTracker::Record.last
-    person = Person.first
-    assert_equal person.name, ta.user.name
+    assert_equal a, ta.user
     assert_equal 'b', ta.get_friend_name[0]
-    f = Friendship.create! :person => create_user('a').person, :friend => create_user('c').person
+    f = Friendship.create! :person => a, :friend => c
     ta = ActionTracker::Record.last
-    assert_equal person.name, ta.user.name
+    assert_equal a, ta.user
     assert_equal 'c', ta.get_friend_name[1]
   end
-  should 'create tracked action only if they are not friends yet' do
+  should 'create tracked action for both people' do
     a, b = create_user('a').person, create_user('b').person
     f = Friendship.create! :person => a, :friend => b
-    assert_equal ['b'], ActionTracker::Record.last.get_friend_name
+    ta = ActionTracker::Record.last
+    assert_equal a, ta.user
+    assert_equal ['b'], ta.get_friend_name
     f = Friendship.create! :person => b, :friend => a
-    assert_equal ['b'], ActionTracker::Record.last.get_friend_name
+    ta = ActionTracker::Record.last
+    assert_equal b, ta.user
+    assert_equal ['a'], ta.get_friend_name
   end
 end
@@ -2,24 +2,168 @@ require File.dirname(__FILE__) + &#39;/../test_helper&#39;
 class NotifyActivityToProfilesJobTest < ActiveSupport::TestCase
-  should 'create the ActionTrackerNotification' do
+  should 'notify just the community in tracker with add_member_in_community verb' do
     person = fast_create(Person)
     community  = fast_create(Community)
-    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'add_member_in_community')
+    assert NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
     p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
     fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
     fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
     fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
     fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
     ActionTrackerNotification.delete_all
-    job = NotifyActivityToProfilesJob.new(action_tracker.id, community.id)
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
     job.perform
     process_delayed_job_queue
-    [community, p1, p2, m1, m2].each do |profile|
+    assert_equal 1, ActionTrackerNotification.count
+    [community].each do |profile|
       notification = ActionTrackerNotification.find_by_profile_id profile.id
       assert_equal action_tracker, notification.action_tracker
     end
   end
+  should 'notify just the community in tracker with remove_member_in_community verb' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'remove_member_in_community')
+    assert NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
+    fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 1, ActionTrackerNotification.count
+    [community].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should 'notify just the users and his friends tracking user actions' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :verb => 'create_article')
+    assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
+    fast_create(Friendship, :person_id => p1.id, :friend_id => m1.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 3, ActionTrackerNotification.count
+    [person, p1, p2].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should 'not notify the communities members' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'create_article')
+    assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 4, ActionTrackerNotification.count
+    [person, community, m1, m2].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should 'notify users its friends, the community and its members' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'create_article')
+    assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
+    fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 6, ActionTrackerNotification.count
+    [person, community, p1, p2, m1, m2].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should 'not notify the community tracking join_community verb' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'join_community')
+    assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
+    fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 5, ActionTrackerNotification.count
+    [person, p1, p2, m1, m2].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should 'not notify the community tracking leave_community verb' do
+    person = fast_create(Person)
+    community  = fast_create(Community)
+    action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'leave_community')
+    assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
+    p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
+    fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
+    fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
+    fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
+    ActionTrackerNotification.delete_all
+    job = NotifyActivityToProfilesJob.new(action_tracker.id)
+    job.perform
+    process_delayed_job_queue
+
+    assert_equal 5, ActionTrackerNotification.count
+    [person, p1, p2, m1, m2].each do |profile|
+      notification = ActionTrackerNotification.find_by_profile_id profile.id
+      assert_equal action_tracker, notification.action_tracker
+    end
+  end
+
+  should "the NOTIFY_ONLY_COMMUNITY constant has all the verbs tested" do
+    notify_community_verbs = ['add_member_in_community', 'remove_member_in_community']
+    assert_equal [], notify_community_verbs - NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY
+    assert_equal [], NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY - notify_community_verbs
+  end
+
+  should "the NOT_NOTIFY_COMMUNITY constant has all the verbs tested" do
+    not_notify_community_verbs = ['join_community', 'leave_community']
+    assert_equal [], not_notify_community_verbs - NotifyActivityToProfilesJob::NOT_NOTIFY_COMMUNITY
+    assert_equal [], NotifyActivityToProfilesJob::NOT_NOTIFY_COMMUNITY - not_notify_community_verbs
+  end
+
 end
@@ -829,7 +829,7 @@ class PersonTest &lt; Test::Unit::TestCase
     end
   end
-  should "the tracked action notify friends with one delayed job process followed by others jobs created after run the firt job" do
+  should "the tracked action notify friends with one delayed job process" do
     p1 = Person.first
     p2 = fast_create(Person)
     p3 = fast_create(Person)
@@ -847,8 +847,7 @@ class PersonTest &lt; Test::Unit::TestCase
     assert_difference(Delayed::Job, :count, 1) do
       Person.notify_activity(action_tracker)
     end
-
-    assert_difference(ActionTrackerNotification, :count, 2) do
+    assert_difference(ActionTrackerNotification, :count, 3) do
       process_delayed_job_queue
     end
   end
@@ -866,13 +865,9 @@ class PersonTest &lt; Test::Unit::TestCase
     assert !p2.is_member_of?(community)
     process_delayed_job_queue
-    action_tracker = fast_create(ActionTracker::Record)
-    article = mock()
-    action_tracker.stubs(:dispatcher).returns(article)
-    article.stubs(:is_a?).with(Article).returns(true)
-    article.stubs(:is_a?).with(RoleAssignment).returns(false)
-    article.stubs(:is_a?).with(Comment).returns(false)
-    article.stubs(:profile).returns(community)
+    action_tracker = fast_create(ActionTracker::Record, :verb => 'create_article')
+    action_tracker.target = community
+    action_tracker.save!
     ActionTrackerNotification.delete_all
     assert_difference(ActionTrackerNotification, :count, 3) do
       Person.notify_activity(action_tracker)
@@ -900,7 +895,7 @@ class PersonTest &lt; Test::Unit::TestCase
     action_tracker = fast_create(ActionTracker::Record)
     article = mock()
-    action_tracker.stubs(:dispatcher).returns(article)
+    action_tracker.stubs(:target).returns(article)
     article.stubs(:is_a?).with(Article).returns(true)
     article.stubs(:is_a?).with(RoleAssignment).returns(false)
     article.stubs(:is_a?).with(Comment).returns(false)
@@ -960,9 +955,47 @@ class PersonTest &lt; Test::Unit::TestCase
     p = create_user('test_user').person
     c = fast_create(Community, :name => "Foo")
     c.add_member(p)
-    assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name
+    assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).get_resource_name
     c.reload.add_moderator(p.reload)
-    assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name
+    assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).get_resource_name
+  end
+
+  should 'the tracker target be Community when a person joins a community' do
+    ActionTracker::Record.delete_all
+    p = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    c.add_member(p)
+    assert_kind_of Community, ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).target
+  end
+
+  should 'the community be notified specifically when a person joins a community' do
+    ActionTracker::Record.delete_all
+    p = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    c.add_member(p)
+    assert_not_nil ActionTracker::Record.last(:conditions => {:verb => 'add_member_in_community'})
+  end
+
+  should 'the community specific notification created when a member joins community could not be propagated to members' do
+    ActionTracker::Record.delete_all
+    p1 = create_user('test_user').person
+    p2 = create_user('test_user').person
+    p3 = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    c.add_member(p1)
+    process_delayed_job_queue
+    c.add_member(p3)
+    process_delayed_job_queue
+    assert_equal 4, ActionTracker::Record.count
+    assert_equal 5, ActionTrackerNotification.count
+    has_add_member_notification = false
+    ActionTrackerNotification.all.map do |notification|
+      if notification.action_tracker.verb == 'add_member_in_community'
+        has_add_member_notification = true
+        assert_equal c, notification.profile
+      end
+    end
+    assert has_add_member_notification
   end
   should 'track only one action when a person leaves a community' do
@@ -972,7 +1005,58 @@ class PersonTest &lt; Test::Unit::TestCase
     c.add_moderator(p)
     ActionTracker::Record.delete_all
     c.remove_member(p)
-    assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name
+    assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'leave_community'}).get_resource_name
+  end
+
+  should 'the tracker target be Community when a person leaves a community' do
+    ActionTracker::Record.delete_all
+    p = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    c.add_member(p)
+    c.add_moderator(p)
+    ActionTracker::Record.delete_all
+    c.remove_member(p)
+    assert_kind_of Community, ActionTracker::Record.last(:conditions => {:verb => 'leave_community'}).target
+  end
+
+  should 'the community be notified specifically when a person leaves a community' do
+    ActionTracker::Record.delete_all
+    p = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    c.add_member(p)
+    c.add_moderator(p)
+    ActionTracker::Record.delete_all
+    c.remove_member(p)
+    assert_not_nil ActionTracker::Record.last(:conditions => {:verb => 'remove_member_in_community'})
+  end
+
+  should 'the community specific notification created when a member leaves community could not be propagated to members' do
+    ActionTracker::Record.delete_all
+    p1 = Person.first
+    p2 = create_user('test_user').person
+    p3 = create_user('test_user').person
+    c = fast_create(Community, :name => "Foo")
+    process_delayed_job_queue
+    Delayed::Job.delete_all
+    c.add_member(p1)
+    c.add_member(p3)
+    c.add_moderator(p1)
+    c.add_moderator(p3)
+    ActionTracker::Record.delete_all
+    c.remove_member(p1)
+    process_delayed_job_queue
+    c.remove_member(p3)
+    process_delayed_job_queue
+    assert_equal 4, ActionTracker::Record.count
+    assert_equal 5, ActionTrackerNotification.count
+    has_remove_member_notification = false
+    ActionTrackerNotification.all.map do |notification|
+      if notification.action_tracker.verb == 'remove_member_in_community'
+        has_remove_member_notification = true
+        assert_equal c, notification.profile
+      end
+    end
+    assert has_remove_member_notification
   end
 end
@@ -137,4 +137,136 @@ class PublishedArticleTest &lt; ActiveSupport::TestCase
     assert_equal p.parent, new_parent
   end
+  should 'notifiable be true' do
+    a = fast_create(PublishedArticle)
+    assert a.notifiable?
+  end
+
+  should 'notify activity on create' do
+    ActionTracker::Record.delete_all
+    a = fast_create(Article)
+    PublishedArticle.create! :reference_article => a, :name => 'test', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+  end
+
+  should 'notify with different trackers activity create with different targets' do
+    ActionTracker::Record.delete_all
+    profile = fast_create(Profile)
+    a = fast_create(Article)
+    PublishedArticle.create! :reference_article => a, :name => 'bar', :profile_id => profile.id, :published => true
+    a = fast_create(Article)
+    PublishedArticle.create! :reference_article => a, :name => 'another bar', :profile_id => profile.id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+    a = fast_create(Article)
+    PublishedArticle.create! :reference_article => a, :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+  end
+
+  should 'notify activity on update' do
+    ActionTracker::Record.delete_all
+    a = fast_create(Article)
+    a = PublishedArticle.create! :reference_article => a, :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+    a.name = 'foo'
+    a.save!
+    assert_equal 2, ActionTracker::Record.count
+  end
+
+  should 'notify with different trackers activity update with different targets' do
+    ActionTracker::Record.delete_all
+    a = fast_create(Article)
+    a1 = PublishedArticle.create! :reference_article => a, :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a = fast_create(Article)
+    a2 = PublishedArticle.create! :reference_article => a, :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.name = 'foo'
+    a1.save!
+    assert_equal 3, ActionTracker::Record.count
+    a2.name = 'another foo'
+    a2.save!
+    assert_equal 4, ActionTracker::Record.count
+  end
+
+  should 'notify activity on destroy' do
+    ActionTracker::Record.delete_all
+    a = fast_create(Article)
+    a = PublishedArticle.create! :reference_article => a, :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+    a.destroy
+    assert_equal 2, ActionTracker::Record.count
+  end
+
+  should 'notify different activities when destroy articles with diferrents targets' do
+    ActionTracker::Record.delete_all
+    a = fast_create(Article)
+    a1 = PublishedArticle.create! :reference_article => a, :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a = fast_create(Article)
+    a2 = PublishedArticle.create! :reference_article => a, :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.destroy
+    assert_equal 3, ActionTracker::Record.count
+    a2.destroy
+    assert_equal 4, ActionTracker::Record.count
+  end
+
+  should "the tracker action target be defined as Community by custom_target method on articles'creation in communities" do
+    ActionTracker::Record.delete_all
+    community = fast_create(Community)
+    p1 = Person.first
+    community.add_member(p1)
+    assert p1.is_member_of?(community)
+    a = fast_create(Article)
+    article = PublishedArticle.create! :reference_article => a, :name => 'test', :profile_id => community.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Community, article.profile.class
+    assert_equal Community, ActionTracker::Record.last.target.class
+  end
+
+  should "the tracker action target be defined as person by custom_target method on articles'creation in profile" do
+    ActionTracker::Record.delete_all
+    person = Person.first
+    a = fast_create(Article)
+    article = PublishedArticle.create! :reference_article => a, :name => 'test', :profile_id => person.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Person, article.profile.class
+    assert_equal person, ActionTracker::Record.last.target
+  end
+
+  should 'not notify activity if the article is not advertise' do
+    ActionTracker::Record.delete_all
+    article = fast_create(Article)
+    a = PublishedArticle.create! :reference_article => article, :name => 'bar', :profile_id => fast_create(Profile).id, :published => true, :advertise => false
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal false, a.image?
+    assert_equal false, a.profile.is_a?(Community)
+    assert_equal 0, ActionTracker::Record.count
+  end
+
+  should "have defined the is_trackable method defined" do
+    assert PublishedArticle.method_defined?(:is_trackable?)
+  end
+
+  should "the common trackable conditions return the correct value" do
+    a =  PublishedArticle.new
+    a.published = a.advertise = true
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal true, a.advertise?
+    assert_equal true, a.is_trackable?
+   
+    a.published=false
+    assert_equal false, a.published?
+    assert_equal false, a.is_trackable?
+
+    a.published=true
+    a.advertise=false
+    assert_equal false, a.advertise?
+    assert_equal false, a.is_trackable?
+  end
+
 end
@@ -38,6 +38,16 @@ class TextileArticleTest &lt; Test::Unit::TestCase
     assert_equal 1, ActionTracker::Record.count
   end
+  should 'notify with different trackers activity create with different targets' do
+    ActionTracker::Record.delete_all
+    profile = fast_create(Profile)
+    TextileArticle.create! :name => 'bar', :profile_id => profile.id, :published => true
+    TextileArticle.create! :name => 'another bar', :profile_id => profile.id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+    TextileArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+  end
+
   should 'notify activity on update' do
     ActionTracker::Record.delete_all
     a = TextileArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
@@ -47,6 +57,19 @@ class TextileArticleTest &lt; Test::Unit::TestCase
     assert_equal 2, ActionTracker::Record.count
   end
+  should 'notify with different trackers activity update with different targets' do
+    ActionTracker::Record.delete_all
+    a1 = TextileArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a2 = TextileArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.name = 'foo'
+    a1.save!
+    assert_equal 3, ActionTracker::Record.count
+    a2.name = 'another foo'
+    a2.save!
+    assert_equal 4, ActionTracker::Record.count
+  end
+
   should 'notify activity on destroy' do
     ActionTracker::Record.delete_all
     a = TextileArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
@@ -55,4 +78,72 @@ class TextileArticleTest &lt; Test::Unit::TestCase
     assert_equal 2, ActionTracker::Record.count
   end
+  should 'notify different activities when destroy articles with diferrents targets' do
+    ActionTracker::Record.delete_all
+    a1 = TextileArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a2 = TextileArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.destroy
+    assert_equal 3, ActionTracker::Record.count
+    a2.destroy
+    assert_equal 4, ActionTracker::Record.count
+  end
+
+  should "the tracker action target be defined as Community by custom_target method on articles'creation in communities" do
+    ActionTracker::Record.delete_all
+    community = fast_create(Community)
+    p1 = Person.first
+    community.add_member(p1)
+    assert p1.is_member_of?(community)
+    article = TextileArticle.create! :name => 'test', :profile_id => community.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Community, article.profile.class
+    assert_equal Community, ActionTracker::Record.last.target.class
+  end
+
+  should "the tracker action target be defined as person by custom_target method on articles'creation in profile" do
+    ActionTracker::Record.delete_all
+    person = Person.first
+    article = TextileArticle.create! :name => 'test', :profile_id => person.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Person, article.profile.class
+    assert_equal person, ActionTracker::Record.last.target
+  end
+
+  should 'not notify activity if the article is not advertise' do
+    ActionTracker::Record.delete_all
+    a = TextileArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true, :advertise => false
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal false, a.image?
+    assert_equal false, a.profile.is_a?(Community)
+    assert_equal 0, ActionTracker::Record.count
+  end
+
+  should "have defined the is_trackable method defined" do
+    assert TextileArticle.method_defined?(:is_trackable?)
+  end
+
+  should "the common trackable conditions return the correct value" do
+    a =  TextileArticle.new
+    a.published = a.advertise = true
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal true, a.advertise?
+    assert_equal true, a.is_trackable?
+   
+    a.published=false
+    assert_equal false, a.published?
+    assert_equal false, a.is_trackable?
+
+    a.published=true
+    a.advertise=false
+    assert_equal false, a.advertise?
+    assert_equal false, a.is_trackable?
+  end
+
 end
@@ -129,6 +129,16 @@ class TinyMceArticleTest &lt; Test::Unit::TestCase
     assert_equal 1, ActionTracker::Record.count
   end
+  should 'notify with different trackers activity create with different targets' do
+    ActionTracker::Record.delete_all
+    profile = fast_create(Profile)
+    TinyMceArticle.create! :name => 'bar', :profile_id => profile.id, :published => true
+    TinyMceArticle.create! :name => 'another bar', :profile_id => profile.id, :published => true
+    assert_equal 1, ActionTracker::Record.count
+    TinyMceArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+  end
+
   should 'notify activity on update' do
     ActionTracker::Record.delete_all
     a = TinyMceArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
@@ -138,6 +148,19 @@ class TinyMceArticleTest &lt; Test::Unit::TestCase
     assert_equal 2, ActionTracker::Record.count
   end
+  should 'notify with different trackers activity update with different targets' do
+    ActionTracker::Record.delete_all
+    a1 = TinyMceArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a2 = TinyMceArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.name = 'foo'
+    a1.save!
+    assert_equal 3, ActionTracker::Record.count
+    a2.name = 'another foo'
+    a2.save!
+    assert_equal 4, ActionTracker::Record.count
+  end
+
   should 'notify activity on destroy' do
     ActionTracker::Record.delete_all
     a = TinyMceArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
@@ -146,4 +169,73 @@ class TinyMceArticleTest &lt; Test::Unit::TestCase
     assert_equal 2, ActionTracker::Record.count
   end
+  should 'notify different activities when destroy articles with diferrents targets' do
+    ActionTracker::Record.delete_all
+    a1 = TinyMceArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true
+    a2 = TinyMceArticle.create! :name => 'another bar', :profile_id => fast_create(Profile).id, :published => true
+    assert_equal 2, ActionTracker::Record.count
+    a1.destroy
+    assert_equal 3, ActionTracker::Record.count
+    a2.destroy
+    assert_equal 4, ActionTracker::Record.count
+  end
+
+  should "the tracker action target be defined as Community by custom_target method on articles'creation in communities" do
+    ActionTracker::Record.delete_all
+    community = fast_create(Community)
+    p1 = Person.first
+    community.add_member(p1)
+    assert p1.is_member_of?(community)
+    article = TinyMceArticle.create! :name => 'test', :profile_id => community.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Community, article.profile.class
+    assert_equal Community, ActionTracker::Record.last.target.class
+  end
+
+  should "the tracker action target be defined as person by custom_target method on articles'creation in profile" do
+    ActionTracker::Record.delete_all
+    person = Person.first
+    article = TinyMceArticle.create! :name => 'test', :profile_id => person.id
+    assert_equal true, article.published?
+    assert_equal true, article.notifiable?
+    assert_equal false, article.image?
+    assert_equal Person, article.profile.class
+    assert_equal person, ActionTracker::Record.last.target
+  end
+
+  should 'not notify activity if the article is not advertise' do
+    ActionTracker::Record.delete_all
+    a = TinyMceArticle.create! :name => 'bar', :profile_id => fast_create(Profile).id, :published => true, :advertise => false
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal false, a.image?
+    assert_equal false, a.profile.is_a?(Community)
+    assert_equal 0, ActionTracker::Record.count
+  end
+
+  should "have defined the is_trackable method defined" do
+    assert TinyMceArticle.method_defined?(:is_trackable?)
+  end
+
+  should "the common trackable conditions return the correct value" do
+    a =  TinyMceArticle.new
+    a.published = a.advertise = true
+    assert_equal true, a.published?
+    assert_equal true, a.notifiable?
+    assert_equal true, a.advertise?
+    assert_equal true, a.is_trackable?
+   
+    a.published=false
+    assert_equal false, a.published?
+    assert_equal false, a.is_trackable?
+
+    a.published=true
+    a.advertise=false
+    assert_equal false, a.advertise?
+    assert_equal false, a.is_trackable?
+  end
+
+
 end
@@ -5,10 +5,14 @@ class RoleAssignment &lt; ActiveRecord::Base
   validates_presence_of :role, :accessor
-  track_actions :join_community, :after_create, :keep_params => ["resource.name", "resource.url", "resource.profile_custom_icon"], :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }
+  track_actions :join_community, :after_create, :keep_params => ["resource.name", "resource.url", "resource.profile_custom_icon"], :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }, :custom_user => :accessor, :custom_target => :resource
-  track_actions :leave_community, :before_destroy, :keep_params => ["resource.name", "resource.url", "resource.profile_custom_icon"], :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }
+  track_actions :add_member_in_community, :after_create, :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }, :custom_user => :accessor, :custom_target => :resource
+  track_actions :leave_community, :before_destroy, :keep_params => ["resource.name", "resource.url", "resource.profile_custom_icon"], :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }, :custom_user => :accessor, :custom_target => :resource
+  
+  track_actions :remove_member_in_community, :before_destroy, :if => Proc.new { |x| x.resource.is_a?(Community) && x.accessor.role_assignments.count(:conditions => { :resource_id => x.resource.id, :resource_type => 'Profile' }) == 1 }, :custom_target => :resource, :custom_user => :accessor
+
   def has_permission?(perm, res)
     return false unless role.has_permission?(perm.to_s) && (resource || is_global)
     return true if is_global
@@ -2,7 +2,7 @@ class CreateActionTracker &lt; ActiveRecord::Migration
   def self.up
     create_table :action_tracker do |t|
       t.belongs_to :user, :polymorphic => true
-      t.belongs_to :dispatcher, :polymorphic => true
+      t.belongs_to :target, :polymorphic => true
       t.text :params
       t.string :verb
       t.timestamps
@@ -10,7 +10,7 @@ class CreateActionTracker &lt; ActiveRecord::Migration
     change_table :action_tracker do |t|
       t.index [:user_id, :user_type]
-      t.index [:dispatcher_id, :dispatcher_type]
+      t.index [:target_id, :target_type]
       t.index :verb
     end
   end
@@ -67,7 +67,9 @@ module ActionTracker
       def track_actions(verb, callback, options = {}, &block)
         keep_params = options.delete(:keep_params) || options.delete('keep_params') || :all
         post_proc = options.delete(:post_processing) || options.delete('post_processing') || Proc.new{}
-        send(callback, Proc.new { |tracked| tracked.save_action_for_verb(verb.to_s, keep_params, post_proc) }, options)
+        custom_user = options.delete(:custom_user) || options.delete('custom_user') || nil
+        custom_target = options.delete(:custom_target) || options.delete('custom_target') || nil
+        send(callback, Proc.new { |tracked| tracked.save_action_for_verb(verb.to_s, keep_params, post_proc, custom_user, custom_target) }, options)
         send :include, InstanceMethods
       end
@@ -86,8 +88,10 @@ module ActionTracker
         time.to_f
       end
-      def save_action_for_verb(verb, keep_params = :all, post_proc = Proc.new{})
-        user = ActionTracker::Record.current_user_from_model
+      def save_action_for_verb(verb, keep_params = :all, post_proc = Proc.new{}, custom_user = nil, custom_target = nil)
+        user = self.send(custom_user) unless custom_user.blank?
+        user ||= ActionTracker::Record.current_user_from_model
+        target = self.send(custom_target) unless custom_target.blank?
         return nil if user.nil?
         if keep_params.is_a? Array
           stored_params = {}
@@ -103,13 +107,13 @@ module ActionTracker
         end
         tracked_action = case ActionTrackerConfig.verb_type(verb)
           when :groupable
-            Record.add_or_create :verb => verb, :params => stored_params
+            Record.add_or_create :verb => verb, :params => stored_params, :user => user, :target => target
           when :updatable
-            Record.update_or_create :verb => verb, :params => stored_params
+            Record.update_or_create :verb => verb, :params => stored_params, :user => user, :target => target
           when :single
-            Record.new :verb => verb, :params => stored_params
+            Record.new :verb => verb, :params => stored_params, :user => user
         end
-        tracked_action.dispatcher = self
+        tracked_action.target = target || self
         user.tracked_actions << tracked_action
         post_proc.call tracked_action.reload
       end
@@ -4,7 +4,7 @@ module ActionTracker
     set_table_name 'action_tracker'
     belongs_to :user, :polymorphic => true
-    belongs_to :dispatcher, :polymorphic => true
+    belongs_to :target, :polymorphic => true
     serialize :params, Hash
@@ -25,7 +25,9 @@ module ActionTracker
     def self.update_or_create(params)
       u = params[:user] || current_user_from_model
       return if u.nil?
-      l = last :conditions => { :user_id => u.id, :user_type => u.class.base_class.to_s, :verb => params[:verb].to_s }
+      target_hash = params[:target].nil? ? {} : {:target_type => params[:target].class.base_class.to_s, :target_id => params[:target].id}
+      conditions = { :user_id => u.id, :user_type => u.class.base_class.to_s, :verb => params[:verb].to_s }.merge(target_hash)
+      l = last :conditions => conditions
       ( !l.nil? and Time.now - l.updated_at < ActionTrackerConfig.timeout ) ? l.update_attributes(params.merge({ :updated_at => Time.now })) : l = new(params)
       l
     end
@@ -33,7 +35,8 @@ module ActionTracker
     def self.add_or_create(params)
       u = params[:user] || current_user_from_model
       return if u.nil?
-      l = last :conditions => { :user_id => u.id, :user_type => u.class.base_class.to_s, :verb => params[:verb].to_s }
+      target_hash = params[:target].nil? ? {} : {:target_type => params[:target].class.base_class.to_s, :target_id => params[:target].id}
+      l = last :conditions => { :user_id => u.id, :user_type => u.class.base_class.to_s, :verb => params[:verb].to_s }.merge(target_hash)
       if !l.nil? and Time.now - l.updated_at < ActionTrackerConfig.timeout
         params[:params].clone.each { |key, value| params[:params][key] = l.params[key].clone.push(value) }
         l.update_attributes params
@@ -11,7 +11,7 @@ ActiveRecord::Schema.define do
   end
   create_table :action_tracker do |t|
     t.belongs_to :user, :polymorphic => true
-    t.belongs_to :dispatcher, :polymorphic => true
+    t.belongs_to :target, :polymorphic => true
     t.text :params
     t.string :verb
     t.timestamps
@@ -29,7 +29,7 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     ActionTrackerConfig.verbs = { :some_verb => { :description => "Did something" } }
     @mymodel = SomeModel.create!
     @othermodel = SomeModel.create!
-    @tracked_action = ActionTracker::Record.create! :verb => :some_verb, :params => { :user => "foo" }, :user => @mymodel, :dispatcher => @othermodel
+    @tracked_action = ActionTracker::Record.create! :verb => :some_verb, :params => { :user => "foo" }, :user => @mymodel, :target => @othermodel
   end
   def test_has_relationship
@@ -47,10 +47,10 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal [@tracked_action], @mymodel.tracked_actions
   end
-  def test_has_a_polymorphic_relation_with_dispatcher
-    assert_equal @othermodel.id, @tracked_action.dispatcher_id
-    assert_equal "SomeModel", @tracked_action.dispatcher_type
-    assert_equal @othermodel, @tracked_action.dispatcher
+  def test_has_a_polymorphic_relation_with_target
+    assert_equal @othermodel.id, @tracked_action.target_id
+    assert_equal "SomeModel", @tracked_action.target_type
+    assert_equal @othermodel, @tracked_action.target
   end
   def test_should_stringify_verb_before_validation
@@ -90,7 +90,7 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal @mymodel, ActionTracker::Record.last.user
   end
-  def test_update_or_create_create_if_no_timeout
+  def test_update_or_create_create_if_timeout
     ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
     ActionTrackerConfig.timeout = 5.minutes
     ActionTracker::Record.delete_all
@@ -111,7 +111,7 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal t, ta.reload.updated_at
   end
-  def test_update_or_create_update_if_timeout
+  def test_update_or_create_update_if_no_timeout
     ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
     ActionTrackerConfig.timeout = 7.minutes
     ActionTracker::Record.delete_all
@@ -134,7 +134,37 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal 3, ta.reload.get_foo
   end
-  def test_add_or_create_create_if_no_timeout
+  def test_should_update_or_create_method_create_a_new_tracker_with_different_dispacthers
+    ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
+    ActionTracker::Record.delete_all
+    ta = nil
+    assert_difference "ActionTracker::Record.count" do
+      ta = ActionTracker::Record.update_or_create :verb => :some, :user => @mymodel, :target => @mymodel, :params => { :foo => 2 }
+      ta.save; ta.reload
+    end
+    assert_kind_of ActionTracker::Record, ta
+    t = ta.reload.updated_at
+    sleep(1)
+    assert_no_difference "ActionTracker::Record.count" do
+      ta2 = ActionTracker::Record.update_or_create :verb => :some, :user => @mymodel, :target => @mymodel, :params => { :foo => 3 }
+      ta2.save; ta2.reload
+      assert_kind_of ActionTracker::Record, ta2
+    end
+    assert_equal 3, ta.reload.get_foo
+    assert_not_equal t, ta.reload.updated_at
+
+    assert_kind_of ActionTracker::Record, ta
+    t = ta.reload.updated_at
+    assert_difference "ActionTracker::Record.count" do
+      ta2 = ActionTracker::Record.update_or_create :verb => :some, :user => @mymodel, :target => @othermodel, :params => { :foo => 4 }
+      ta2.save; ta2.reload
+      assert_kind_of ActionTracker::Record, ta2
+    end
+    assert_equal t, ta.reload.updated_at
+    assert_equal 3, ta.reload.get_foo
+  end
+
+  def test_add_or_create_create_if_timeout
     ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :groupable } }
     ActionTrackerConfig.timeout = 5.minutes
     ActionTracker::Record.delete_all
@@ -157,7 +187,7 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal ["test"], ActionTracker::Record.last.params[:foo]
   end
-  def test_add_or_create_update_if_timeout
+  def test_add_or_create_update_if_no_timeout
     ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
     ActionTrackerConfig.timeout = 7.minutes
     ActionTracker::Record.delete_all
@@ -188,6 +218,30 @@ class ActionTrackerModelTest &lt; ActiveSupport::TestCase
     assert_equal [2, 1, 1], ActionTracker::Record.last.params[:bar]
   end
+  def test_add_or_create_create_if_no_timeout_and_different_target
+    ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
+    ActionTrackerConfig.timeout = 7.minutes
+    ActionTracker::Record.delete_all
+    ta = nil
+    assert_difference "ActionTracker::Record.count" do
+      ta = ActionTracker::Record.add_or_create :verb => :some, :user => @mymodel, :target => @mymodel, :params => { :foo => "test 1", :bar => 2 }
+      ta.save; ta.reload
+    end
+    assert_kind_of ActionTracker::Record, ta
+    assert_equal ["test 1"], ta.params[:foo]
+    assert_equal [2], ta.params[:bar]
+    ta.updated_at = Time.now.ago(6.minutes)
+    ta.send :update_without_callbacks
+    t = ta.reload.updated_at
+    assert_difference "ActionTracker::Record.count" do
+      ta2 = ActionTracker::Record.add_or_create :verb => :some, :user => @mymodel, :target => @othermodel, :params => { :foo => "test 2", :bar => 1 }
+      ta2.save; ta2.reload
+      assert_kind_of ActionTracker::Record, ta2
+    end
+    assert_equal ["test 1"], ta.params[:foo]
+    assert_equal [2], ta.params[:bar]
+  end
+
   def test_time_spent
     ActionTracker::Record.delete_all
     ActionTrackerConfig.verbs = { :some => { :description => "Something", :type => :updatable } }
@@ -15,7 +15,7 @@ ActiveRecord::Schema.define do
   end
   create_table :action_tracker do |t|
     t.belongs_to :user, :polymorphic => true
-    t.belongs_to :dispatcher, :polymorphic => true
+    t.belongs_to :target, :polymorphic => true
     t.text :params
     t.string :verb
     t.timestamps
@@ -29,6 +29,7 @@ end
 class OtherModel < ActiveRecord::Base
   set_table_name :other_table
+  acts_as_trackable
 end
 class ThingsController < ActionController::Base
@@ -38,7 +39,7 @@ class ThingsController &lt; ActionController::Base
     render :text => "test"
   end
-	def test
+  def test
     render :text => "test"
   end
@@ -490,7 +491,81 @@ class ActionTrackerTest &lt; ActiveSupport::TestCase
         get :test
       end
     end
-		assert_equal "test", OtherModel.last.other_column
+    assert_equal "test", OtherModel.last.other_column
+  end
+
+  def test_track_actions_custom_user_as_symbol
+    ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
+    model = create_model do
+      track_actions :test, :after_create, :custom_user => :test_custom_user
+      def current_user
+        SomeModel.create!
+      end
+      def test_custom_user
+        OtherModel.create!
+      end
+    end
+    @controller = create_controller_for_model(model, :another_column => 2)
+    assert_difference('ActionTracker::Record.count') { get :test }
+		assert_kind_of OtherModel, ActionTracker::Record.last.user
+  end
+
+  def test_track_actions_custom_user_as_string
+    ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
+    model = create_model do
+      track_actions :test, :after_create, "custom_user" => :test_custom_user
+      def current_user
+        SomeModel.create!
+      end
+      def test_custom_user
+        OtherModel.create!
+      end
+    end
+    @controller = create_controller_for_model(model, :another_column => 2)
+    assert_difference('ActionTracker::Record.count') { get :test }
+		assert_kind_of OtherModel, ActionTracker::Record.last.user
+  end
+
+  def test_track_actions_custom_user_is_nil_by_default
+    ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
+    model = create_model do
+      track_actions :test, :after_create
+      def current_user
+        SomeModel.create!
+      end
+      def test_custom_user
+        OtherModel.create!
+      end
+    end
+    @controller = create_controller_for_model(model, :another_column => 2)
+    assert_difference('ActionTracker::Record.count') { get :test }
+		assert_kind_of SomeModel, ActionTracker::Record.last.user
+  end
+
+  def test_track_actions_custom_target_as_symbol
+    ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
+    model = create_model do
+      track_actions :test, :after_create, :custom_target => :test_custom_target
+      def test_custom_target
+        SomeModel.create!
+      end
+    end
+    @controller = create_controller_for_model(model, :another_column => 2)
+    assert_difference('ActionTracker::Record.count') { get :test }
+		assert_kind_of SomeModel, ActionTracker::Record.last.target
+  end
+
+  def test_track_actions_custom_target_as_string
+    ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
+    model = create_model do
+      track_actions :test, :after_create, "custom_target" => :test_custom_target
+      def test_custom_target
+        SomeModel.create!
+      end
+    end
+    @controller = create_controller_for_model(model, :another_column => 2)
+    assert_difference('ActionTracker::Record.count') { get :test }
+		assert_kind_of SomeModel, ActionTracker::Record.last.target
   end
   def test_acts_as_trackable_with_options
@@ -515,7 +590,7 @@ class ActionTrackerTest &lt; ActiveSupport::TestCase
     end
   end
-  def test_track_actions_save_dispatcher
+  def test_track_actions_save_target
     ActionTrackerConfig.verbs = { :test => { :description => "Some" } }
     model = create_model do
       track_actions :test, :after_create
@@ -524,7 +599,7 @@ class ActionTrackerTest &lt; ActiveSupport::TestCase
     assert_difference 'ActionTracker::Record.count' do
       get :test
     end
-    assert_kind_of model.base_class, ActionTracker::Record.last.dispatcher
+    assert_kind_of model.base_class, ActionTracker::Record.last.target
   end
   private
@@ -30,12 +30,14 @@ class UserStampSweeper &lt; ActionController::Caching::Sweeper
   def before_validation(record)
     return unless current_user
-    if record.respond_to?(UserStamp.creator_assignment_method) && record.new_record?
-      record.send(UserStamp.creator_assignment_method, current_user)
+    attribute, method = UserStamp.creator_attribute, UserStamp.creator_assignment_method
+    if record.respond_to?(method) && record.new_record?
+      record.send(method, current_user) unless record.send("#{attribute}_id_changed?") || record.send("#{attribute}_type_changed?")
     end
-    if record.respond_to?(UserStamp.updater_assignment_method)
-      record.send(UserStamp.updater_assignment_method, current_user)
+    attribute, method = UserStamp.updater_attribute, UserStamp.updater_assignment_method
+    if record.respond_to?(method)
+      record.send(method, current_user) if record.send(attribute).blank?
     end
   end
@@ -2,58 +2,59 @@ require File.dirname(__FILE__) + &#39;/spec_helper&#39;
 class PostsController
   def self.current_user
-    User.new(220)
+    @@user
   end
 end
 describe UserStampSweeper, "#before_validation" do
   before do
-    UserStamp.creator_attribute   = :creator_id
-    UserStamp.updater_attribute   = :updater_id
+    @@user = User.new(220)
+    UserStamp.creator_attribute   = :creator
+    UserStamp.updater_attribute   = :updater
     UserStamp.current_user_method = :current_user
     @sweeper = UserStampSweeper.instance
     @sweeper.stub!(:controller).and_return(PostsController)
   end
   describe "(with new record)" do
-    it "should set creator_id if attribute exists" do
-      record = mock('Record', :creator_id= => nil, :updater_id= => nil, :new_record? => true)
-      record.should_receive(:creator_id=).with(220).once
+    it "should set creator if attribute exists" do
+      record = mock('Record', :creator= => nil, :updater= => nil, :new_record? => true, :updater => nil, :creator_id_changed? => false, :creator_type_changed? => false, :updater_id_changed? => false, :updater_type_changed? => false)
+      record.should_receive(:creator=).with(@@user).once
       @sweeper.before_validation(record)
     end
-    it "should NOT set creator_id if attribute does not exist" do
-      record = mock('Record', :new_record? => true, :updater_id= => nil, :respond_to? => false)
-      record.should_receive(:respond_to?).with("creator_id=").and_return(false)
-      record.should_not_receive(:creator_id=)
+    it "should NOT set creator if attribute does not exist" do
+      record = mock('Record', :new_record? => true, :updater= => nil, :respond_to? => false)
+      record.should_receive(:respond_to?).with("creator=").and_return(false)
+      record.should_not_receive(:creator=)
       @sweeper.before_validation(record)
     end
   end
   describe "(with non new record)" do
-    it "should NOT set creator_id if attribute exists" do
-      record = mock('Record', :creator_id= => nil, :updater_id= => nil, :new_record? => false)
-      record.should_not_receive(:creator_id=)
+    it "should NOT set creator if attribute exists" do
+      record = mock('Record', :creator= => nil, :updater= => nil, :updater => nil, :new_record? => false, :creator_id_changed? => false, :creator_type_changed? => false, :updater_id_changed? => false, :updater_type_changed? => false)
+      record.should_not_receive(:creator=)
       @sweeper.before_validation(record)
     end
-    it "should NOT set creator_id if attribute does not exist" do
-      record = mock('Record', :updater_id= => nil, :new_record? => false)
-      record.should_not_receive(:creator_id=)
+    it "should NOT set creator if attribute does not exist" do
+      record = mock('Record', :updater= => nil, :updater => nil, :new_record? => false, :creator_id_changed? => false, :creator_type_changed? => false, :updater_id_changed? => false, :updater_type_changed? => false)
+      record.should_not_receive(:creator=)
       @sweeper.before_validation(record)
     end
   end
-  it "should set updater_id if attribute exists" do
-    record = mock('Record', :creator_id= => nil, :updater_id= => nil, :new_record? => :false)
-    record.should_receive(:updater_id=)
+  it "should set updater if attribute exists" do
+    record = mock('Record', :creator= => nil, :updater= => nil, :new_record? => false, :updater => nil)
+    record.should_receive(:updater=)
     @sweeper.before_validation(record)
   end
-  it "should NOT set updater_id if attribute does not exist" do
-    record = mock('Record', :creator_id= => nil, :updater_id= => nil, :new_record? => :false, :respond_to? => false)
-    record.should_receive(:respond_to?).with("updater_id=").and_return(false)
-    record.should_not_receive(:updater_id=)
+  it "should NOT set updater if attribute does not exist" do
+    record = mock('Record', :creator= => nil, :updater= => nil, :new_record? => :false, :respond_to? => false)
+    record.should_receive(:respond_to?).with("updater=").and_return(false)
+    record.should_not_receive(:updater=)
     @sweeper.before_validation(record)
   end
 end
@@ -69,8 +70,8 @@ describe UserStampSweeper, &quot;#before_validation (with custom attribute names)&quot; do
   describe "(with new record)" do
     it "should set created_by if attribute exists" do
-      record = mock('Record', :created_by= => nil, :updated_by= => nil, :new_record? => true)
-      record.should_receive(:created_by=).with(220).once
+      record = mock('Record', :created_by= => nil, :updated_by => nil, :updated_by= => nil, :new_record? => true, :created_by_id_changed? => false, :created_by_type_changed? => false, :updated_by_id_changed? => false, :updated_by_type_changed? => false)
+      record.should_receive(:created_by=).with(@@user).once
       @sweeper.before_validation(record)
     end
@@ -84,20 +85,20 @@ describe UserStampSweeper, &quot;#before_validation (with custom attribute names)&quot; do
   describe "(with non new record)" do
     it "should NOT set created_by if attribute exists" do
-      record = mock('Record', :created_by= => nil, :updated_by= => nil, :new_record? => false)
+      record = mock('Record', :created_by= => nil, :updated_by => nil, :updated_by= => nil, :new_record? => false, :updated_by_id_changed? => false, :updated_by_type_changed? => false)
       record.should_not_receive(:created_by=)
       @sweeper.before_validation(record)
     end
     it "should NOT set created_by if attribute does not exist" do
-      record = mock('Record', :updated_by= => nil, :new_record? => false)
+      record = mock('Record', :updated_by= => nil, :updated_by => nil, :new_record? => false, :updated_by_id_changed? => false, :updated_by_type_changed? => false)
       record.should_not_receive(:created_by=)
       @sweeper.before_validation(record)
     end
   end
   it "should set updated_by if attribute exists" do
-    record = mock('Record', :created_by= => nil, :updated_by= => nil, :new_record? => :false)
+    record = mock('Record', :created_by= => nil, :updated_by= => nil, :updated_by => nil, :new_record? => :false, :created_by_id_changed? => false, :created_by_type_changed? => false, :updated_by_id_changed? => false, :updated_by_type_changed? => false)
     record.should_receive(:updated_by=)
     @sweeper.before_validation(record)
   end
@@ -108,12 +109,44 @@ describe UserStampSweeper, &quot;#before_validation (with custom attribute names)&quot; do
     record.should_not_receive(:updated_by=)
     @sweeper.before_validation(record)
   end
+
+  it "should NOT set created_by if attribute changed" do
+    record = mock('Record', :created_by= => nil, :updated_by= => nil, :new_record? => true, :created_by_id_changed? => true, :created_by_type_changed? => true)
+    record.should_receive(:respond_to?).with("updated_by=").and_return(false)
+    record.should_receive(:respond_to?).with("created_by=").and_return(true)
+    record.should_not_receive(:created_by=)
+    @sweeper.before_validation(record)
+  end
+
+  it "should NOT set updated_by if attribute is not nil" do
+    record = mock('Record', :created_by= => nil, :updated_by= => nil, :updated_by => 1, :new_record? => false)
+    record.should_receive(:respond_to?).with("updated_by=").and_return(true)
+    record.should_receive(:respond_to?).with("created_by=").and_return(false)
+    record.should_not_receive(:updated_by=)
+    @sweeper.before_validation(record)
+  end
+
+  it "should set created_by if attribute has not changed" do
+    record = mock('Record', :created_by= => nil, :updated_by= => nil, :new_record? => true, :created_by_id_changed? => false, :created_by_type_changed? => false)
+    record.should_receive(:respond_to?).with("updated_by=").and_return(false)
+    record.should_receive(:respond_to?).with("created_by=").and_return(true)
+    record.should_receive(:created_by=)
+    @sweeper.before_validation(record)
+  end
+
+  it "should set updated_by if attribute is nil" do
+    record = mock('Record', :created_by= => nil, :updated_by= => nil, :updated_by => nil, :new_record? => false)
+    record.should_receive(:respond_to?).with("updated_by=").and_return(true)
+    record.should_receive(:respond_to?).with("created_by=").and_return(false)
+    record.should_receive(:updated_by=)
+    @sweeper.before_validation(record)
+  end
 end
 describe UserStampSweeper, "#current_user" do
   before do
-    UserStamp.creator_attribute   = :creator_id
-    UserStamp.updater_attribute   = :updater_id
+    UserStamp.creator_attribute   = :creator
+    UserStamp.updater_attribute   = :updater
     UserStamp.current_user_method = :current_user
     @sweeper = UserStampSweeper.instance
   end
@@ -137,8 +170,8 @@ end
 describe UserStampSweeper, "#current_user (with custom current_user_method)" do
   before do
-    UserStamp.creator_attribute   = :creator_id
-    UserStamp.updater_attribute   = :updater_id
+    UserStamp.creator_attribute   = :creator
+    UserStamp.updater_attribute   = :updater
     UserStamp.current_user_method = :my_user
     @sweeper = UserStampSweeper.instance
   end
@@ -158,4 +191,4 @@ describe UserStampSweeper, &quot;#current_user (with custom current_user_method)&quot; do
     controller.should_not_receive(:my_user)
     @sweeper.send(:current_user)
   end
-end
 \ No newline at end of file
+end
1	class Friendship < ActiveRecord::Base	1	class Friendship < ActiveRecord::Base
2	- track_actions :new_friendship, :after_create, :keep_params => ["friend.name", "friend.url", "friend.profile_custom_icon"], :unless => Proc.new { \|f\| f.friend.is_a_friend?(f.person) }	2	+ track_actions :new_friendship, :after_create, :keep_params => ["friend.name", "friend.url", "friend.profile_custom_icon"], :custom_user => :person
3		3
4	belongs_to :person, :foreign_key => :person_id	4	belongs_to :person, :foreign_key => :person_id
5	belongs_to :friend, :class_name => 'Person', :foreign_key => 'friend_id'	5	belongs_to :friend, :class_name => 'Person', :foreign_key => 'friend_id'
	@@ -37,4 +37,8 @@ class PublishedArticle < Article		@@ -37,4 +37,8 @@ class PublishedArticle < Article
37	reference_article && reference_article.abstract	37	reference_article && reference_article.abstract
38	end	38	end
39		39
		40	+ def notifiable?
		41	+ true
		42	+ end
		43	+
40	end	44	end
@@ -0,0 +1,13 @@		@@ -0,0 +1,13 @@
	1	+class ChangeActionTrackerRecord < ActiveRecord::Migration
	2	+ def self.up
	3	+ rename_column(:action_tracker, :dispatcher_type, :target_type)
	4	+ rename_column(:action_tracker, :dispatcher_id, :target_id)
	5	+ ActionTracker::Record.update_all("verb='create_article'", {:verb => 'publish_article_in_community'})
	6	+ end
	7	+
	8	+ def self.down
	9	+ raise "this migration can't be reverted"
	10	+ rename_column(:action_tracker, :target_type, :dispatcher_type)
	11	+ rename_column(:action_tracker, :target_id, :dispatcher_id)
	12	+ end
	13	+end
1	-class NotifyActivityToProfilesJob < Struct.new(:tracked_action_id, :target_profile_id)	1	+class NotifyActivityToProfilesJob < Struct.new(:tracked_action_id)
		2	+ NOTIFY_ONLY_COMMUNITY = [
		3	+ 'add_member_in_community',
		4	+ 'remove_member_in_community',
		5	+ ]
		6	+
		7	+ NOT_NOTIFY_COMMUNITY = [
		8	+ 'join_community',
		9	+ 'leave_community',
		10	+ ]
2	def perform	11	def perform
3	- profile = Profile.find(target_profile_id) unless target_profile_id.nil?
4	tracked_action = ActionTracker::Record.find(tracked_action_id)	12	tracked_action = ActionTracker::Record.find(tracked_action_id)
		13	+ target = tracked_action.target
		14	+ if target.is_a?(Community) && NOTIFY_ONLY_COMMUNITY.include?(tracked_action.verb)
		15	+ ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => target)
		16	+ return
		17	+ end
		18	+
		19	+ ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => tracked_action.user)
5	tracked_action.user.each_friend do \|friend\|	20	tracked_action.user.each_friend do \|friend\|
6	ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => friend)	21	ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => friend)
7	end	22	end
8	- if profile.is_a?(Community)
9	- profile.each_member do \|member\|	23	+
		24	+ if target.is_a?(Community)
		25	+ target.each_member do \|member\|
10	next if member == tracked_action.user	26	next if member == tracked_action.user
11	ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => member)	27	ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => member)
12	end	28	end
13	- ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => profile)	29	+ ActionTrackerNotification.create(:action_tracker => tracked_action, :profile => target) unless NOT_NOTIFY_COMMUNITY.include?(tracked_action.verb)
14	end	30	end
15	end	31	end
16	end	32	end
	@@ -224,7 +224,7 @@ module Noosfero::Factory		@@ -224,7 +224,7 @@ module Noosfero::Factory
224	alias :defaults_for_textile_article :defaults_for_article	224	alias :defaults_for_textile_article :defaults_for_article
225	alias :defaults_for_tiny_mce_article :defaults_for_article	225	alias :defaults_for_tiny_mce_article :defaults_for_article
226	alias :defaults_for_rss_feed :defaults_for_article	226	alias :defaults_for_rss_feed :defaults_for_article
227	- alias :defaults_for_textile_article :defaults_for_article	227	+ alias :defaults_for_published_article :defaults_for_article
228	alias :defaults_for_folder :defaults_for_article	228	alias :defaults_for_folder :defaults_for_article
229		229
230	###############################################	230	###############################################
	@@ -381,7 +381,7 @@ module Noosfero::Factory		@@ -381,7 +381,7 @@ module Noosfero::Factory
381	###############################################	381	###############################################
382		382
383	def defaults_for_action_tracker_record(params = {})	383	def defaults_for_action_tracker_record(params = {})
384	- { :created_at => DateTime.now, :verb => :leave_comment, :user_type => 'Profile', :user_id => 1 }.merge(params)	384	+ { :created_at => DateTime.now, :verb => 'add_member_in_community', :user_type => 'Profile', :user_id => 1 }.merge(params)
385	end	385	end
386		386
387	###############################################	387	###############################################
	@@ -769,7 +769,8 @@ class ProfileControllerTest < Test::Unit::TestCase		@@ -769,7 +769,8 @@ class ProfileControllerTest < Test::Unit::TestCase
769		769
770	should 'the network activity be paginated' do	770	should 'the network activity be paginated' do
771	p1= Person.first	771	p1= Person.first
772	- 40.times{Scrap.create!(defaults_for_scrap(:sender => p1, :receiver => p1))}	772	+ at = fast_create(ActionTracker::Record)
		773	+ 40.times{fast_create(ActionTrackerNotification, :action_tracker_id => at.id, :profile_id => p1.id)}
773		774
774	@controller.stubs(:logged_in?).returns(true)	775	@controller.stubs(:logged_in?).returns(true)
775	user = mock()	776	user = mock()
	@@ -1020,4 +1020,40 @@ class ArticleTest < Test::Unit::TestCase		@@ -1020,4 +1020,40 @@ class ArticleTest < Test::Unit::TestCase
1020	assert_equal 0, ActionTracker::Record.count	1020	assert_equal 0, ActionTracker::Record.count
1021	end	1021	end
1022		1022
		1023	+ should "the action_tracker_target method be defined" do
		1024	+ assert Article.method_defined?(:action_tracker_target)
		1025	+ end
		1026	+
		1027	+ should "the action_tracker_target method return the article profile" do
		1028	+ profile = fast_create(Person)
		1029	+ article = fast_create(Article, :profile_id => profile.id)
		1030	+ assert_equal profile, article.action_tracker_target
		1031	+
		1032	+ profile = fast_create(Community)
		1033	+ article = fast_create(Article, :profile_id => profile.id)
		1034	+ assert_equal profile, article.action_tracker_target
		1035	+ end
		1036	+
		1037	+ should "have defined the is_trackable method defined" do
		1038	+ assert Article.method_defined?(:is_trackable?)
		1039	+ end
		1040	+
		1041	+ should "the common trackable conditions return the correct value" do
		1042	+ a = Article.new
		1043	+ a.published = a.advertise = true
		1044	+ assert_equal true, a.published?
		1045	+ assert_equal false, a.notifiable?
		1046	+ assert_equal true, a.advertise?
		1047	+ assert_equal false, a.is_trackable?
		1048	+
		1049	+ a.published=false
		1050	+ assert_equal false, a.published?
		1051	+ assert_equal false, a.is_trackable?
		1052	+
		1053	+ a.published=true
		1054	+ a.advertise=false
		1055	+ assert_equal false, a.advertise?
		1056	+ assert_equal false, a.is_trackable?
		1057	+ end
		1058	+
1023	end	1059	end
	@@ -226,4 +226,16 @@ class CommentTest < Test::Unit::TestCase		@@ -226,4 +226,16 @@ class CommentTest < Test::Unit::TestCase
226	assert_equal comment.url, ta.get_url	226	assert_equal comment.url, ta.get_url
227	end	227	end
228		228
		229	+ should 'have the action_tracker_target defined' do
		230	+ assert Comment.method_defined?(:action_tracker_target)
		231	+ end
		232	+
		233	+ should "have the action_tracker_target be the articles's profile" do
		234	+ owner = create_user('testuser').person
		235	+ article = owner.articles.create!(:name => 'test', :body => '...')
		236	+ comment = article.comments.create!(:article => article, :name => 'foo', :title => 'bar', :body => 'my comment', :email => 'cracker@test.org')
		237	+ ta = ActionTracker::Record.last
		238	+ assert_equal owner, ta.target
		239	+ end
		240	+
229	end	241	end
	@@ -2,24 +2,168 @@ require File.dirname(__FILE__) + '/../test_helper'		@@ -2,24 +2,168 @@ require File.dirname(__FILE__) + '/../test_helper'
2		2
3	class NotifyActivityToProfilesJobTest < ActiveSupport::TestCase	3	class NotifyActivityToProfilesJobTest < ActiveSupport::TestCase
4		4
5	- should 'create the ActionTrackerNotification' do	5	+ should 'notify just the community in tracker with add_member_in_community verb' do
6	person = fast_create(Person)	6	person = fast_create(Person)
7	community = fast_create(Community)	7	community = fast_create(Community)
8	- action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id)	8	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'add_member_in_community')
		9	+ assert NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
9	p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)	10	p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
10	fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)	11	fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
11	fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)	12	fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
12	fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)	13	fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
13	fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)	14	fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
14	ActionTrackerNotification.delete_all	15	ActionTrackerNotification.delete_all
15	- job = NotifyActivityToProfilesJob.new(action_tracker.id, community.id)	16	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
16	job.perform	17	job.perform
17	process_delayed_job_queue	18	process_delayed_job_queue
18		19
19	- [community, p1, p2, m1, m2].each do \|profile\|	20	+ assert_equal 1, ActionTrackerNotification.count
		21	+ [community].each do \|profile\|
20	notification = ActionTrackerNotification.find_by_profile_id profile.id	22	notification = ActionTrackerNotification.find_by_profile_id profile.id
21	assert_equal action_tracker, notification.action_tracker	23	assert_equal action_tracker, notification.action_tracker
22	end	24	end
23	end	25	end
24		26
		27	+ should 'notify just the community in tracker with remove_member_in_community verb' do
		28	+ person = fast_create(Person)
		29	+ community = fast_create(Community)
		30	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'remove_member_in_community')
		31	+ assert NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		32	+ p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		33	+ fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
		34	+ fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
		35	+ fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
		36	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		37	+ ActionTrackerNotification.delete_all
		38	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		39	+ job.perform
		40	+ process_delayed_job_queue
		41	+
		42	+ assert_equal 1, ActionTrackerNotification.count
		43	+ [community].each do \|profile\|
		44	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		45	+ assert_equal action_tracker, notification.action_tracker
		46	+ end
		47	+ end
		48	+
		49	+ should 'notify just the users and his friends tracking user actions' do
		50	+ person = fast_create(Person)
		51	+ community = fast_create(Community)
		52	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :verb => 'create_article')
		53	+ assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		54	+ p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		55	+ fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
		56	+ fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
		57	+ fast_create(Friendship, :person_id => p1.id, :friend_id => m1.id)
		58	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		59	+ ActionTrackerNotification.delete_all
		60	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		61	+ job.perform
		62	+ process_delayed_job_queue
		63	+
		64	+ assert_equal 3, ActionTrackerNotification.count
		65	+ [person, p1, p2].each do \|profile\|
		66	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		67	+ assert_equal action_tracker, notification.action_tracker
		68	+ end
		69	+ end
		70	+
		71	+ should 'not notify the communities members' do
		72	+ person = fast_create(Person)
		73	+ community = fast_create(Community)
		74	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'create_article')
		75	+ assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		76	+ m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		77	+ fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
		78	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		79	+ ActionTrackerNotification.delete_all
		80	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		81	+ job.perform
		82	+ process_delayed_job_queue
		83	+
		84	+ assert_equal 4, ActionTrackerNotification.count
		85	+ [person, community, m1, m2].each do \|profile\|
		86	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		87	+ assert_equal action_tracker, notification.action_tracker
		88	+ end
		89	+ end
		90	+
		91	+ should 'notify users its friends, the community and its members' do
		92	+ person = fast_create(Person)
		93	+ community = fast_create(Community)
		94	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'create_article')
		95	+ assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		96	+ p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		97	+ fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
		98	+ fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
		99	+ fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
		100	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		101	+ ActionTrackerNotification.delete_all
		102	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		103	+ job.perform
		104	+ process_delayed_job_queue
		105	+
		106	+ assert_equal 6, ActionTrackerNotification.count
		107	+ [person, community, p1, p2, m1, m2].each do \|profile\|
		108	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		109	+ assert_equal action_tracker, notification.action_tracker
		110	+ end
		111	+ end
		112	+
		113	+ should 'not notify the community tracking join_community verb' do
		114	+ person = fast_create(Person)
		115	+ community = fast_create(Community)
		116	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'join_community')
		117	+ assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		118	+ p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		119	+ fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
		120	+ fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
		121	+ fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
		122	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		123	+ ActionTrackerNotification.delete_all
		124	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		125	+ job.perform
		126	+ process_delayed_job_queue
		127	+
		128	+ assert_equal 5, ActionTrackerNotification.count
		129	+ [person, p1, p2, m1, m2].each do \|profile\|
		130	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		131	+ assert_equal action_tracker, notification.action_tracker
		132	+ end
		133	+ end
		134	+
		135	+ should 'not notify the community tracking leave_community verb' do
		136	+ person = fast_create(Person)
		137	+ community = fast_create(Community)
		138	+ action_tracker = fast_create(ActionTracker::Record, :user_type => 'Profile', :user_id => person.id, :target_type => 'Profile', :target_id => community.id, :verb => 'leave_community')
		139	+ assert !NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY.include?(action_tracker.verb)
		140	+ p1, p2, m1, m2 = fast_create(Person), fast_create(Person), fast_create(Person), fast_create(Person)
		141	+ fast_create(Friendship, :person_id => person.id, :friend_id => p1.id)
		142	+ fast_create(Friendship, :person_id => person.id, :friend_id => p2.id)
		143	+ fast_create(RoleAssignment, :accessor_id => m1.id, :role_id => 3, :resource_id => community.id)
		144	+ fast_create(RoleAssignment, :accessor_id => m2.id, :role_id => 3, :resource_id => community.id)
		145	+ ActionTrackerNotification.delete_all
		146	+ job = NotifyActivityToProfilesJob.new(action_tracker.id)
		147	+ job.perform
		148	+ process_delayed_job_queue
		149	+
		150	+ assert_equal 5, ActionTrackerNotification.count
		151	+ [person, p1, p2, m1, m2].each do \|profile\|
		152	+ notification = ActionTrackerNotification.find_by_profile_id profile.id
		153	+ assert_equal action_tracker, notification.action_tracker
		154	+ end
		155	+ end
		156	+
		157	+ should "the NOTIFY_ONLY_COMMUNITY constant has all the verbs tested" do
		158	+ notify_community_verbs = ['add_member_in_community', 'remove_member_in_community']
		159	+ assert_equal [], notify_community_verbs - NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY
		160	+ assert_equal [], NotifyActivityToProfilesJob::NOTIFY_ONLY_COMMUNITY - notify_community_verbs
		161	+ end
		162	+
		163	+ should "the NOT_NOTIFY_COMMUNITY constant has all the verbs tested" do
		164	+ not_notify_community_verbs = ['join_community', 'leave_community']
		165	+ assert_equal [], not_notify_community_verbs - NotifyActivityToProfilesJob::NOT_NOTIFY_COMMUNITY
		166	+ assert_equal [], NotifyActivityToProfilesJob::NOT_NOTIFY_COMMUNITY - not_notify_community_verbs
		167	+ end
		168	+
25	end	169	end
	@@ -829,7 +829,7 @@ class PersonTest < Test::Unit::TestCase		@@ -829,7 +829,7 @@ class PersonTest < Test::Unit::TestCase
829	end	829	end
830	end	830	end
831		831
832	- should "the tracked action notify friends with one delayed job process followed by others jobs created after run the firt job" do	832	+ should "the tracked action notify friends with one delayed job process" do
833	p1 = Person.first	833	p1 = Person.first
834	p2 = fast_create(Person)	834	p2 = fast_create(Person)
835	p3 = fast_create(Person)	835	p3 = fast_create(Person)
	@@ -847,8 +847,7 @@ class PersonTest < Test::Unit::TestCase		@@ -847,8 +847,7 @@ class PersonTest < Test::Unit::TestCase
847	assert_difference(Delayed::Job, :count, 1) do	847	assert_difference(Delayed::Job, :count, 1) do
848	Person.notify_activity(action_tracker)	848	Person.notify_activity(action_tracker)
849	end	849	end
850	-
851	- assert_difference(ActionTrackerNotification, :count, 2) do	850	+ assert_difference(ActionTrackerNotification, :count, 3) do
852	process_delayed_job_queue	851	process_delayed_job_queue
853	end	852	end
854	end	853	end
	@@ -866,13 +865,9 @@ class PersonTest < Test::Unit::TestCase		@@ -866,13 +865,9 @@ class PersonTest < Test::Unit::TestCase
866	assert !p2.is_member_of?(community)	865	assert !p2.is_member_of?(community)
867	process_delayed_job_queue	866	process_delayed_job_queue
868		867
869	- action_tracker = fast_create(ActionTracker::Record)
870	- article = mock()
871	- action_tracker.stubs(:dispatcher).returns(article)
872	- article.stubs(:is_a?).with(Article).returns(true)
873	- article.stubs(:is_a?).with(RoleAssignment).returns(false)
874	- article.stubs(:is_a?).with(Comment).returns(false)
875	- article.stubs(:profile).returns(community)	868	+ action_tracker = fast_create(ActionTracker::Record, :verb => 'create_article')
		869	+ action_tracker.target = community
		870	+ action_tracker.save!
876	ActionTrackerNotification.delete_all	871	ActionTrackerNotification.delete_all
877	assert_difference(ActionTrackerNotification, :count, 3) do	872	assert_difference(ActionTrackerNotification, :count, 3) do
878	Person.notify_activity(action_tracker)	873	Person.notify_activity(action_tracker)
	@@ -900,7 +895,7 @@ class PersonTest < Test::Unit::TestCase		@@ -900,7 +895,7 @@ class PersonTest < Test::Unit::TestCase
900		895
901	action_tracker = fast_create(ActionTracker::Record)	896	action_tracker = fast_create(ActionTracker::Record)
902	article = mock()	897	article = mock()
903	- action_tracker.stubs(:dispatcher).returns(article)	898	+ action_tracker.stubs(:target).returns(article)
904	article.stubs(:is_a?).with(Article).returns(true)	899	article.stubs(:is_a?).with(Article).returns(true)
905	article.stubs(:is_a?).with(RoleAssignment).returns(false)	900	article.stubs(:is_a?).with(RoleAssignment).returns(false)
906	article.stubs(:is_a?).with(Comment).returns(false)	901	article.stubs(:is_a?).with(Comment).returns(false)
	@@ -960,9 +955,47 @@ class PersonTest < Test::Unit::TestCase		@@ -960,9 +955,47 @@ class PersonTest < Test::Unit::TestCase
960	p = create_user('test_user').person	955	p = create_user('test_user').person
961	c = fast_create(Community, :name => "Foo")	956	c = fast_create(Community, :name => "Foo")
962	c.add_member(p)	957	c.add_member(p)
963	- assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name	958	+ assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).get_resource_name
964	c.reload.add_moderator(p.reload)	959	c.reload.add_moderator(p.reload)
965	- assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name	960	+ assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).get_resource_name
		961	+ end
		962	+
		963	+ should 'the tracker target be Community when a person joins a community' do
		964	+ ActionTracker::Record.delete_all
		965	+ p = create_user('test_user').person
		966	+ c = fast_create(Community, :name => "Foo")
		967	+ c.add_member(p)
		968	+ assert_kind_of Community, ActionTracker::Record.last(:conditions => {:verb => 'join_community'}).target
		969	+ end
		970	+
		971	+ should 'the community be notified specifically when a person joins a community' do
		972	+ ActionTracker::Record.delete_all
		973	+ p = create_user('test_user').person
		974	+ c = fast_create(Community, :name => "Foo")
		975	+ c.add_member(p)
		976	+ assert_not_nil ActionTracker::Record.last(:conditions => {:verb => 'add_member_in_community'})
		977	+ end
		978	+
		979	+ should 'the community specific notification created when a member joins community could not be propagated to members' do
		980	+ ActionTracker::Record.delete_all
		981	+ p1 = create_user('test_user').person
		982	+ p2 = create_user('test_user').person
		983	+ p3 = create_user('test_user').person
		984	+ c = fast_create(Community, :name => "Foo")
		985	+ c.add_member(p1)
		986	+ process_delayed_job_queue
		987	+ c.add_member(p3)
		988	+ process_delayed_job_queue
		989	+ assert_equal 4, ActionTracker::Record.count
		990	+ assert_equal 5, ActionTrackerNotification.count
		991	+ has_add_member_notification = false
		992	+ ActionTrackerNotification.all.map do \|notification\|
		993	+ if notification.action_tracker.verb == 'add_member_in_community'
		994	+ has_add_member_notification = true
		995	+ assert_equal c, notification.profile
		996	+ end
		997	+ end
		998	+ assert has_add_member_notification
966	end	999	end
967		1000
968	should 'track only one action when a person leaves a community' do	1001	should 'track only one action when a person leaves a community' do
	@@ -972,7 +1005,58 @@ class PersonTest < Test::Unit::TestCase		@@ -972,7 +1005,58 @@ class PersonTest < Test::Unit::TestCase
972	c.add_moderator(p)	1005	c.add_moderator(p)
973	ActionTracker::Record.delete_all	1006	ActionTracker::Record.delete_all
974	c.remove_member(p)	1007	c.remove_member(p)
975	- assert_equal ["Foo"], ActionTracker::Record.last.get_resource_name	1008	+ assert_equal ["Foo"], ActionTracker::Record.last(:conditions => {:verb => 'leave_community'}).get_resource_name
		1009	+ end
		1010	+
		1011	+ should 'the tracker target be Community when a person leaves a community' do
		1012	+ ActionTracker::Record.delete_all
		1013	+ p = create_user('test_user').person
		1014	+ c = fast_create(Community, :name => "Foo")
		1015	+ c.add_member(p)
		1016	+ c.add_moderator(p)
		1017	+ ActionTracker::Record.delete_all
		1018	+ c.remove_member(p)
		1019	+ assert_kind_of Community, ActionTracker::Record.last(:conditions => {:verb => 'leave_community'}).target
		1020	+ end
		1021	+
		1022	+ should 'the community be notified specifically when a person leaves a community' do
		1023	+ ActionTracker::Record.delete_all
		1024	+ p = create_user('test_user').person
		1025	+ c = fast_create(Community, :name => "Foo")
		1026	+ c.add_member(p)
		1027	+ c.add_moderator(p)
		1028	+ ActionTracker::Record.delete_all
		1029	+ c.remove_member(p)
		1030	+ assert_not_nil ActionTracker::Record.last(:conditions => {:verb => 'remove_member_in_community'})
		1031	+ end
		1032	+
		1033	+ should 'the community specific notification created when a member leaves community could not be propagated to members' do
		1034	+ ActionTracker::Record.delete_all
		1035	+ p1 = Person.first
		1036	+ p2 = create_user('test_user').person
		1037	+ p3 = create_user('test_user').person
		1038	+ c = fast_create(Community, :name => "Foo")
		1039	+ process_delayed_job_queue
		1040	+ Delayed::Job.delete_all
		1041	+ c.add_member(p1)
		1042	+ c.add_member(p3)
		1043	+ c.add_moderator(p1)
		1044	+ c.add_moderator(p3)
		1045	+ ActionTracker::Record.delete_all
		1046	+ c.remove_member(p1)
		1047	+ process_delayed_job_queue
		1048	+ c.remove_member(p3)
		1049	+ process_delayed_job_queue
		1050	+ assert_equal 4, ActionTracker::Record.count
		1051	+ assert_equal 5, ActionTrackerNotification.count
		1052	+ has_remove_member_notification = false
		1053	+ ActionTrackerNotification.all.map do \|notification\|
		1054	+ if notification.action_tracker.verb == 'remove_member_in_community'
		1055	+ has_remove_member_notification = true
		1056	+ assert_equal c, notification.profile
		1057	+ end
		1058	+ end
		1059	+ assert has_remove_member_notification
976	end	1060	end
977		1061
978	end	1062	end