community_engine 2.0.0.beta1

data/test/unit/topic_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+class TopicTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def test_save_should_update_post_id_for_posts_belonging_to_topic
+    # checking current forum_id's are in sync
+    topic = topics(:pdi)
+    post_forums = lambda do
+      topic.sb_posts.each { |p| assert_equal p.forum_id, topic.forum_id }
+    end
+    post_forums.call
+    assert_equal forums(:rails).id, topic.forum_id
+    
+    # updating forum_id
+    topic.update_attribute :forum_id, forums(:comics).id
+    assert_equal forums(:comics).id, topic.reload.forum_id
+    post_forums.call
+  end
+
+  def test_knows_last_post
+    assert_equal sb_posts(:pdi_rebuttal), topics(:pdi).sb_posts.recent.last
+  end
+  
+  def test_should_add_to_user_counter_cache
+    assert_difference SbPost, :count do
+      assert_difference users(:sam).sb_posts, :count do
+        p = topics(:galactus).sb_posts.new(:body => "I'll do it")
+        p.user = users(:sam)
+        p.save
+      end
+    end
+  end
+ 
+  def test_should_create_topic
+    counts = lambda { [Topic.count, forums(:rails).topics_count] }
+    old = counts.call
+    t = forums(:rails).topics.new(:title => 'foo')
+    t.user = users(:aaron)
+    assert t.valid?
+    t.save
+    assert_equal 0, t.sticky
+    [forums(:rails), users(:aaron)].each &:reload
+    assert_equal old.collect { |n| n + 1}, counts.call
+  end
+  
+  def test_should_delete_topic
+    counts = lambda { [Topic.count, SbPost.count, forums(:rails).topics_count, forums(:rails).sb_posts_count,  users(:sam).sb_posts_count] }
+    old = counts.call
+    topics(:ponies).destroy
+    [forums(:rails), users(:sam)].each &:reload
+    assert_equal old.collect { |n| n - 1}, counts.call
+  end
+  
+  def test_hits
+    hits=topics(:pdi).views
+    topics(:pdi).hit!
+    topics(:pdi).hit!
+    assert_equal(topics(:pdi).hits, topics(:pdi).views)      
+    assert_equal(hits+2, topics(:pdi).reload.hits)
+  end
+  
+  def test_replied_at_set
+    t=Topic.new
+    t.user=users(:aaron)
+    t.title = "happy life"
+    t.forum = forums(:rails)
+    assert t.save
+    assert_not_nil t.replied_at
+    assert t.replied_at <= Time.now.utc
+    assert_in_delta t.replied_at, Time.now.utc, 5.seconds
+  end
+  
+  def test_doesnt_change_replied_at_on_save
+    t=Topic.find(:first)
+    old=t.replied_at
+    assert t.save
+    assert_equal old, t.replied_at
+  end
+
+  def test_notify_of_new_post
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      # aaron and sam are monitoring, but aaron's the author, so just one notification
+      topics(:pdi).notify_of_new_post( topics(:pdi).sb_posts.last )
+    end
+  end
+
+  test "should notify for new anonymous post" do
+    configatron.allow_anonymous_forum_posting = true
+    assert_difference ActionMailer::Base.deliveries, :length, 2 do
+      post = topics(:pdi).sb_posts.create!(:body => "Anonymous post", :author_email => 'foo@bar.com', :author_ip => '1.2.3.4')
+    end    
+    configatron.allow_anonymous_forum_posting = false
+  end
+  
+  def test_topic_creator_should_monitor_automatically
+    t = forums(:rails).topics.new(:title => 'foo')
+    t.user = users(:aaron)
+    t.save  
+    assert users(:aaron).monitoring_topic?(t)
+  end
+  
+  def test_should_be_deleted_when_user_destroyed
+    topic = topics(:ponies)
+    id = topic.id
+    topic.user.destroy
+    assert !Topic.exists?(id)
+  end
+
+  
+end

data/test/unit/user_notifier_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+require 'hpricot'
+
+class UserNotifierTest < ActiveSupport::TestCase
+  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  CHARSET = "utf-8"
+
+  fixtures :users, :friendships, :friendship_statuses, :comments, :posts, :sb_posts, :topics, :forums, :roles
+
+  def setup
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+
+  end
+
+  def test_should_deliver_signup_invitation_with_name_in_email
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.signup_invitation('"Foo Bar" <foo@bar.com>', users(:quentin), 'please join').deliver
+    end
+  end
+
+
+  def test_should_deliver_signup_invitation  
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.signup_invitation('test@example.com', users(:quentin), 'please join').deliver
+    end
+  end
+
+  def test_should_deliver_friendship_request  
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.friendship_request(friendships(:aaron_receive_quentin_pending)).deliver
+    end
+  end
+  
+  def test_should_deliver_friendship_accepted_notification
+    f = friendships(:aaron_receive_quentin_pending)    
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      f.update_attributes(:friendship_status => FriendshipStatus[:accepted]) && f.reverse.update_attributes(:friendship_status => FriendshipStatus[:accepted])          
+    end    
+  end
+  
+  def test_should_deliver_comment_notice
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.comment_notice(comments(:aarons_comment_on_quentins_post)).deliver
+    end
+  end
+  
+  def test_should_deliver_follow_up_comment_notice
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.follow_up_comment_notice(users(:dwr), comments(:aarons_comment_on_quentins_post)).deliver
+    end    
+  end
+  
+  def test_should_deliver_follow_up_comment_notice_anonymous
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.follow_up_comment_notice_anonymous('test@example.com', comments(:aarons_comment_on_quentins_post)).deliver
+    end    
+  end  
+  
+  def test_should_deliver_new_forum_post_notice
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.new_forum_post_notice(users(:dwr), sb_posts(:ponies)).deliver
+    end        
+  end
+  
+
+  def test_should_deliver_signup_notification
+    users(:aaron).update_attributes(:activated_at => nil, :activation_code => "123456")
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.signup_notification(users(:aaron)).deliver
+    end
+  end
+
+  def test_should_deliver_post_recommendation
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.post_recommendation('foo', 'bar@example.com', posts(:funny_post), 'check it out').deliver
+    end    
+  end
+  
+  def test_should_deliver_activation
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.activation(users(:aaron)).deliver
+    end    
+  end
+  
+  def test_should_deliver_password_reset_instructions
+    activate_authlogic
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.password_reset_instructions(users(:aaron)).deliver
+    end    
+  end
+
+  def test_should_deliver_forgot_username
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      UserNotifier.forgot_username(users(:aaron)).deliver
+    end    
+  end
+  
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/user_notifier/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, CHARSET)
+    end
+end

data/test/unit/user_test.rb

@@ -0,0 +1,259 @@
+require 'test_helper'
+
+class UserTest < ActiveSupport::TestCase
+  fixtures :all  
+
+  test "should_create_user" do
+    assert_difference User, :count do
+      user = create_user
+      assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+    end
+  end
+  
+  test "should_trim_whitespace" do
+    user = users(:quentin)
+    user.login = 'quentin    '
+    user.save!
+    assert_equal user.login, 'quentin'
+  end
+
+  test "should_not_reject_spaces" do
+    user = User.new(:login => 'foo bar')
+    user.valid?
+    assert user.errors[:login].empty?
+  end
+
+  test "should_reject_special_chars" do
+    user = User.new(:login => '&stripes')
+    assert !user.valid?
+    assert user.errors[:login]
+  end
+  
+  test "should_accept_normal_chars_in_login" do
+    u = create_user(:login => "foo_and_bar")
+    assert u.errors[:login].empty?
+    u = create_user(:login => "2foo-and-bar")
+    assert u.errors[:login].empty?
+  end
+
+  test "should_require_login" do
+    assert_no_difference User, :count do
+      u = create_user(:login => nil)
+      assert u.errors[:login]
+    end
+  end
+  
+  test "should_find_user_with_numerals_in_login" do
+    u = create_user(:login => "2foo-and-bar")
+    assert u.errors[:login].empty?
+    assert_equal u, User.find("2foo-and-bar")
+  end
+    
+  test "should_require_password" do
+    assert_no_difference User, :count do
+      u = create_user(:password => nil)
+      assert u.errors[:password]
+    end
+  end
+
+  test "should_require_password_confirmation" do
+    assert_no_difference User, :count do
+      u = create_user(:password_confirmation => nil)
+      assert u.errors[:password_confirmation]
+    end
+  end
+
+  test "should_require_email" do
+    assert_no_difference User, :count do
+      u = create_user(:email => nil)
+      assert u.errors[:email]
+    end
+  end
+  
+  test "should_require_valid_birthday" do
+    assert_no_difference User, :count do
+      u = create_user(:birthday => 1.year.ago)
+      assert u.errors[:birthday].any?
+    end
+  end  
+
+  test "should_handle_email_upcase" do
+    assert_difference User, :count, 1 do
+      assert create_user(:email => 'FOO@BAR.NET').valid?
+    end
+  end
+
+  test "should_update_password" do
+    activate_authlogic
+    users(:quentin).update_attributes(:password => 'new password', :password_confirmation => 'new password')
+    assert_equal users(:quentin), UserSession.create(:login => 'quentin', :password => 'new password').record
+  end
+  
+  test "should deliver password reset instructions" do
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      users(:quentin).deliver_password_reset_instructions!
+    end
+  end
+
+  test "should_not_rehash_password" do
+    activate_authlogic
+    users(:quentin).update_attributes(:login => 'quentin_two')
+    assert_equal users(:quentin), UserSession.create(:login => 'quentin_two', :password => 'test').record
+  end
+
+  test "should_show_location" do
+    assert_equal users(:quentin).location, metro_areas(:twincities).name
+  end
+  
+  test "should_call_avatar_photo" do
+    assert_equal users(:quentin).avatar_photo_url, configatron.photo.missing_medium
+    assert_equal users(:quentin).avatar_photo_url(:thumb), configatron.photo.missing_thumb
+  end
+    
+  test "should_find_featured" do
+    featured = User.find_featured
+    assert_equal featured.size, 1
+  end
+
+  test "should_find_by_activity" do
+    assert_difference Activity, :count, 3 do
+      users(:quentin).track_activity(:logged_in)
+      users(:quentin).track_activity(:logged_in)
+      users(:quentin).track_activity(:logged_in)            
+    end
+
+    assert !User.find_by_activity({:require_avatar => false}).empty?
+    
+    users(:quentin).update_attribute(:avatar_id, 1) #just pretend
+    assert !User.find_by_activity.empty?    
+  end
+  
+  test "should_not_include_inactive_users_in_find_by_activity" do
+    inactive_user = create_user
+    assert !inactive_user.active?
+    Activity.create(:user => inactive_user)
+    assert_nothing_raised do
+      User.find_by_activity({:limit => 5, :require_avatar => false})
+    end
+  end  
+  
+  
+  test "should_update_activities_counter_on_user" do
+    #make sure the initial count is right
+    Activity.destroy_all
+    users(:quentin).update_attribute( :activities_count, Activity.by(users(:quentin)) )
+    
+    assert_difference users(:quentin), :activities_count, 1 do
+      users(:quentin).track_activity(:logged_in)
+      users(:quentin).reload
+    end
+  end
+
+
+  test "should_have_reached_daily_friend_request_limit" do
+    Friendship.daily_request_limit = 1
+    
+    assert !users(:quentin).has_reached_daily_friend_request_limit?
+    f = Friendship.create!(:user => users(:quentin), :friend => users(:kevin), :initiator => true, :friendship_status => FriendshipStatus[:pending])
+    assert users(:quentin).has_reached_daily_friend_request_limit?
+  end
+  
+  test "get_network_activity" do
+    users(:aaron).track_activity(:logged_in) #create an activity
+        
+    u = users(:quentin)
+    f = friendships(:aaron_receive_quentin_pending)
+    f.update_attributes(:friendship_status => FriendshipStatus[:accepted]) && f.reverse.update_attributes(:friendship_status => FriendshipStatus[:accepted])
+    assert !u.network_activity.empty?    
+  end
+  
+  test "should_get_comments_activity" do
+    user = users(:quentin)
+        
+    2.times do
+      comment = user.comments.create!(:comment => "foo", :user => users(:aaron), :recipient => user)
+    end
+    
+    assert_equal 2, user.comments_activity.size
+  end
+  
+  test "should_deactivate" do
+    assert users(:quentin).active?
+    users(:quentin).deactivate
+    assert !users(:quentin).reload.active?
+  end
+
+  test "should activate and send email" do
+    #make quentin inactive
+    users(:quentin).deactivate
+    assert !users(:quentin).reload.active?
+    
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do    
+      users(:quentin).activate
+      assert users(:quentin).reload.active?
+    end
+  end
+
+  test "should_return_full_location" do
+    assert_equal "Minneapolis / St. Paul", users(:quentin).full_location    
+  end
+  
+  test "should_prohibit_reserved_logins    " do
+    user = create_user(:login => configatron.reserved_logins.first)
+    assert !user.valid?
+  end
+  
+  test "should find user tagged with a tag" do
+    user = users(:quentin)
+    user.tag_list = 'foo'
+    user.save
+
+    assert User.tagged_with('foo').include?(user)
+  end
+  
+  test "should prepare params for search" do
+    params = User.prepare_params_for_search(:metro_area_id => 1, :state_id => 1)
+    assert_equal(params, {:metro_area_id=>1, :state_id=>1, "metro_area_id"=>1, "state_id"=>1, "country_id"=>nil})
+  end
+  
+  test "should build scope for search params" do
+    params = {'country_id' => 1, 'state_id' => 1, 'metro_area_id' => 1, 'login' => 'foo', 'vendor' => false, 'description' => 'baz'}
+    scope = User.build_conditions_for_search(params)
+
+    #This sucks; I want to make sure that the correct scopes are set up on the relation, but I don't know a better way.
+    assert_equal("SELECT \"users\".* FROM \"users\"  WHERE \"users\".\"metro_area_id\" = 1 AND (users.activated_at IS NOT NULL) AND (`users`.login LIKE '%foo%') AND (`users`.description LIKE '%baz%')", scope.to_sql)
+  end
+
+  test "should create user from authorization" do
+    hash = {'provider' => 'twitter',
+      'uid' => '12345',
+      'nickname' => 'omniauthuser',
+      'email' => 'email@example.com' } 
+      
+    Authorization.create!(hash) do |auth|
+      assert_difference User, :count, 1 do
+        user = User.find_or_create_from_authorization(auth)
+        auth.user = user        
+      end      
+    end
+    
+  end
+  
+  test "should not require password or email for omniauthed user" do
+    user = User.new
+    user.authorizing_from_omniauth = true
+    user.valid?
+    assert(user.errors[:email].empty?, "Should not have errors on email")
+    assert(user.errors[:birthday].empty?, "Should not have errors on birthday")    
+  end
+  
+  protected
+    def create_user(options = {})      
+      User.create({ 
+        :login => 'quire', 
+        :email => 'quire@example.com', 
+        :password => 'quire123', 
+        :password_confirmation => 'quire123', 
+        :birthday => configatron.min_age.years.ago }.merge(options))
+    end
+end

data/test/unit/vote_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class VoteTest < ActiveSupport::TestCase
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/vendor/plugins/activity_tracker/README

@@ -0,0 +1,4 @@
+ActivityTracker
+===============
+
+Description goes here

data/vendor/plugins/activity_tracker/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the activity_tracker plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the activity_tracker plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActivityTracker'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/plugins/activity_tracker/generators/activity_migration/USAGE

@@ -0,0 +1,13 @@
+Description:
+    The migration generator creates a migration to add the activities table to your database
+
+    The generator takes no arguments.
+
+    The generator creates a migration in db/migrate.
+
+Example:
+    ./script/generate activity_migration
+	
+	Migration:  db/migrate/add_activities_table.rb
+	The Activity model lives in the lib directory of this plugin. You can move that model into your models directory and modify it if you like.
+

data/vendor/plugins/activity_tracker/generators/activity_migration/activity_migration_generator.rb

@@ -0,0 +1,11 @@
+class ActivityMigrationGenerator < Rails::Generator::Base
+
+  def manifest
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate', :assigns => {
+        :migration_name => "CreateActivitiesTable"
+      }, :migration_file_name => "create_activities_table"
+    end
+  end
+
+end

data/vendor/plugins/activity_tracker/generators/activity_migration/templates/migration.rb

@@ -0,0 +1,17 @@
+class CreateActivitiesTable < ActiveRecord::Migration
+  def self.up
+    create_table :activities do |t|
+      t.column :user_id, :integer, :limit => 10
+      t.column :action, :string, :limit => 50
+      t.column :item_id, :integer, :limit => 10
+      t.column :item_type, :string
+      t.column :created_at, :datetime
+    end
+
+
+  end
+
+  def self.down
+    drop_table :activities
+  end
+end

data/vendor/plugins/activity_tracker/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send(:include, ActivityTracker)

data/vendor/plugins/activity_tracker/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/vendor/plugins/activity_tracker/lib/activity.rb

@@ -0,0 +1,40 @@
+class Activity < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :item, :polymorphic => true
+  validates_presence_of :user_id
+  
+  after_save :update_counter_on_user
+  
+  scope :of_item_type, lambda {|type|
+    {:conditions => ["activities.item_type = ?", type]}
+  }
+  scope :since, lambda { |time|
+    {:conditions => ["activities.created_at > ?", time] }
+  }
+  scope :before, lambda {|time|
+    {:conditions => ["activities.created_at < ?", time] }    
+  }
+  scope :recent, :order => "activities.created_at DESC"
+  scope :by_users, lambda {|user_ids|
+    {:conditions => ['activities.user_id in (?)', user_ids]}
+  }
+  
+  
+  def update_counter_on_user
+    if user && user.class.column_names.include?('activities_count')
+      new_count =  Activity.by(user)
+      user.update_attribute(:activities_count, new_count )
+    end
+  end
+  
+  def self.by(user)
+    Activity.count(:all, :conditions => ["user_id = ?", user.id])
+  end
+  
+  def can_be_deleted_by?(user)
+    return false if user.nil?
+    return false unless user.admin? || user.moderator? || self.user_id.eql?(user.id)
+    true
+  end
+    
+end

data/vendor/plugins/activity_tracker/lib/activity_tracker.rb

@@ -0,0 +1,80 @@
+module ActivityTracker # :nodoc:
+
+  def self.included(base) # :nodoc:
+    base.extend ActMethods
+  end
+  
+  module ActMethods
+
+    # Arguments: 
+    #   <tt>:actor</tt> - the user model that owns this object. In most cases this will be :user. Required.
+    #   <tt>:options</tt> - hash of options.
+    #
+    #
+    # Options:
+    #   <tt>:if</tt> - a Proc that determines if the activity should be tracked.
+    #
+    # Examples:
+    #   acts_as_activity :user
+    #   acts_as_activity :author
+    #   acts_as_activity :user, :if => Proc.new{|record| record.post.length > 100 } - will only track the activity if the length of the post is more than 100
+    def acts_as_activity(actor, options = {})
+      unless included_modules.include? InstanceMethods
+        after_create do |record|
+          unless options[:if].kind_of?(Proc) and not options[:if].call(record)
+            record.create_activity_from_self 
+          end
+        end
+
+        has_many :activities, :as => :item, :dependent => :destroy
+        class_attribute :activity_options
+        include InstanceMethods
+      end      
+      self.activity_options = {:actor => actor}
+    end
+    
+    # This adds a helper method to the model which makes it easy to track actions that can't be associated with an object in the database.
+    # Options:
+    #   <tt>:actions</tt> - An array of actions that are accepted to be tracked.
+    #
+    # Examples: 
+    #   tracks_unlinked_activities [:logged_in, :invited_friends] - class.track_activity(:logged_in)
+    #
+    def tracks_unlinked_activities(actions = [])
+      unless included_modules.include? InstanceMethods
+        class_attribute :activity_options
+        include InstanceMethods
+      end
+      self.activity_options = {:actions => actions}    
+      after_destroy { |record| Activity.destroy_all(:user_id => record.id) }
+    end
+        
+  end
+
+  module InstanceMethods
+
+    def create_activity_from_self
+      activity = Activity.new
+      activity.item = self
+      activity.action = self.class.to_s.underscore
+      actor_id = self.send( activity_options[:actor].to_s + "_id" )
+      activity.user_id = actor_id
+      activity.save
+    end
+
+    def track_activity(action)
+      if activity_options[:actions].include?(action)
+        activity = Activity.new
+        activity.action = action.to_s
+        activity.user_id = self.id
+        activity.save!
+      else
+        raise "The action #{action} can't be tracked."
+      end
+    end    
+
+    
+  end
+
+
+end

data/vendor/plugins/activity_tracker/tasks/activity_tracker_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :activity_tracker do
+#   # Task goes here
+# end