community_engine 2.0.0.beta1

data/test/unit/metro_area_test.rb

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

data/test/unit/moderatorship_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class ModeratorshipTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def test_should_find_moderators
+    assert_equal [users(:sam)], forums(:rails).moderators
+  end
+  
+  def test_should_find_moderated_forums
+    assert_equal [forums(:rails)], users(:sam).forums
+  end
+  
+  def test_should_add_moderator
+    assert_equal [], forums(:comics).moderators
+    assert_difference Moderatorship, :count, 1 do
+      forums(:comics).moderators << users(:sam)
+    end
+    assert_equal [users(:sam)], forums(:comics).moderators(true)
+  end
+  
+  def test_should_not_add_duplicate_moderator
+    assert_equal [users(:sam)], forums(:rails).moderators
+    assert_difference Moderatorship, :count, 0 do
+      assert_raise ActiveRecord::RecordInvalid do 
+        forums(:rails).moderators << users(:sam)
+      end
+    end
+  end
+end

data/test/unit/monitorships_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class MonitorshipsTest < ActiveSupport::TestCase
+  all_fixtures
+
+  def test_should_find_monitorships_from_users
+    assert_equal [monitorships(:aaron_pdi)], users(:aaron).monitorships
+    assert_equal [monitorships(:sam_pdi)],   users(:sam).monitorships
+  end
+  
+  def test_should_find_monitorships_from_topics
+    assert_equal [monitorships(:aaron_pdi), monitorships(:sam_pdi)], topics(:pdi).monitorships
+  end
+  
+  def test_should_find_active_watchers
+    assert_equal [users(:aaron)], topics(:pdi).monitors
+  end
+
+  def test_should_find_monitored_topics_for_user
+    assert_equal [topics(:pdi)], users(:aaron).monitored_topics
+  end
+  
+  def test_should_not_find_inactive_monitored_topics
+    assert_equal [], users(:sam).monitored_topics
+  end
+  
+  def test_should_not_find_any_monitored_topics
+    assert_equal [], users(:joe).monitored_topics
+  end
+  
+  def test_should_be_deleted_when_user_destroyed
+    m = monitorships(:aaron_pdi)
+    id = m.id
+    m.user.destroy
+    assert !Monitorship.exists?(id)
+  end  
+  
+end

data/test/unit/page_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'hpricot'
+    
+class PageTest < ActiveSupport::TestCase
+  fixtures :pages
+
+  def test_should_find_including_unpublished
+    page = pages(:draft_page)
+    page.save_as_draft
+    assert Page.unscoped.all.include?(page)
+  end
+  
+  def test_default_find_should_not_find_drafts
+    page = pages(:draft_page)
+    page.save_as_draft
+    assert !Page.all.include?(page)    
+  end
+  
+  def test_default_find_should_find_published
+    page = pages(:custom_page)
+    page.save
+    assert Page.find(:all).include?(page)    
+  end
+
+end

data/test/unit/photo_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class PhotoTest < ActiveSupport::TestCase
+  include ActionDispatch::TestProcess
+
+  fixtures :all
+
+  # Replace this with your real tests.
+  def test_should_find_related_photos
+    photos = Photo.find_related_to(photos(:library_pic))
+    assert photos.empty?
+  end
+  
+  def test_should_find_recent
+    photos = Photo.find_recent(:limit => 1)
+    assert_equal photos.size, 1
+  end
+  
+  def test_should_find_previous_photo
+    previous = photos(:library_pic).previous_photo
+    assert_equal previous, photos(:another_pic)
+  end
+  
+  def test_should_find_next_photo
+    next_photo = photos(:another_pic).next_photo
+    assert_equal next_photo, photos(:library_pic)
+  end  
+  
+  def test_display_name
+    photos(:another_pic).name = nil
+    assert photos(:another_pic).display_name
+  end
+  
+  def test_should_create_photo
+    assert_difference Photo, :count, 1 do
+      photo = Photo.new :photo => fixture_file_upload('/files/library.jpg', 'image/jpg')
+      photo.user = users(:quentin)
+      photo.save!      
+    end
+  end
+  
+end

data/test/unit/poll_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class PollTest < ActiveSupport::TestCase
+
+  def test_should_be_invalid_without_question
+    p = Poll.new(:question => nil)
+    assert !p.valid?
+    assert p.errors[:question]
+  end
+  
+  def test_should_be_invalid_without_post
+    p = Poll.new(:post => nil)
+    assert !p.valid?
+    assert p.errors[:post]
+  end
+  
+  def test_should_create_poll
+    assert Poll.create(:post_id => 1, :question => 'Do you like things?')
+  end
+  
+  def test_should_find_popular
+    assert Poll.find_popular
+  end
+
+end

data/test/unit/post_test.rb

@@ -0,0 +1,212 @@
+require 'test_helper'
+require 'hpricot'
+    
+class PostTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def setup
+    Favorite.destroy_all
+  end
+
+  def test_should_find_including_unpublished
+    post = posts(:funny_post)
+    post.save_as_draft
+    assert Post.unscoped.find(post.id)
+    assert Post.unscoped.all.include?(post)
+  end
+  
+  def test_default_find_should_not_find_drafts
+    post = posts(:funny_post)
+    post.save_as_draft
+    assert !Post.find(:all).include?(post)    
+  end
+  
+  def test_should_find_recent
+    posts = Post.find_recent(:limit => 3)
+    assert_equal posts.size, 3
+    posts = Post.find_recent
+    assert_equal posts.size, 4
+  end
+
+  def test_should_find_popular
+    posts = Post.find_popular(:limit => 3, :since => 10.days)
+    assert_equal 3, posts.size
+    posts = Post.find_popular(:limit => 3, :since => 1.days)
+    assert_equal posts.size, 0
+  end
+  
+  def test_should_display_name
+    post = posts(:funny_post)
+    assert_equal post.display_title, "HOW TO: Building communities is all about love."
+  end
+  
+  def test_should_find_previous_post
+    previous = posts(:not_funny_post).previous_post
+    assert_equal previous, posts(:funny_post)
+  end
+  
+  def test_should_find_next_post
+    next_post = posts(:funny_post).next_post
+    assert_equal next_post, posts(:not_funny_post)
+  end
+  
+  def test_should_track_post_activity
+    assert_difference Activity, :count, 1 do
+      post = Post.new(:title => 'testing activity tracking', :raw_post => 'will this work?', :published_as => 'live')
+      post.user = users(:quentin)
+      post.save!
+    end
+  end
+  
+  def test_should_not_track_draft_post_activity
+    assert_no_difference Activity, :count do
+      post = Post.new(:title => 'testing activity tracking', :raw_post => 'will this work?', :published_as => 'draft')
+      post.user = users(:quentin)
+      post.save!
+    end
+  end  
+  
+  def test_should_delete_post_activity
+    post = Post.new(:title => 'testing activity tracking', :raw_post => 'will this work?', :published_as => 'live')
+    post.user = users(:quentin)
+    post.save!
+
+    assert_difference Activity, :count, -1 do
+      post.destroy
+    end
+  end
+  
+  
+  # def test_link_for_rss
+  #   assert_equal posts(:funny_post).link_for_rss, "http://localhost:3000/quentin/posts/1-This-is-really-good-stuff"
+  # end
+  
+  def test_create_poll
+    assert_difference Poll, :count, 1 do
+      assert_difference Choice, :count, 3 do
+        assert posts(:funny_post).create_poll({:question => 'Who can have a great time?'}, ['I can', 'You can', 'No one can'])
+      end
+    end
+  end
+  
+  def test_should_not_add_empty_poll
+    assert_no_difference Poll, :count do
+      assert_no_difference Choice, :count do
+        posts(:funny_post).create_poll({:question => 'Who can have a great time?'}, ['only one choice'])
+      end
+    end    
+  end
+  
+  def test_should_not_create_poll_with_no_choices
+    assert_no_difference Poll, :count do
+      assert_no_difference Choice, :count do
+        posts(:funny_post).create_poll({:question => 'Who can have a great time?'}, [])
+      end
+    end    
+  end
+  
+  def test_update_poll
+    assert posts(:not_funny_post).create_poll({:question => 'Who can have a great time?'}, ['I can', 'You can', 'No one can'])
+    
+    assert posts(:not_funny_post).update_poll({:question => 'Who can have a terrible time?'}, ['Foo', 'Bar'])
+    
+    assert_equal 'Who can have a terrible time?', posts(:not_funny_post).poll.question 
+    assert_equal 'Foo', posts(:not_funny_post).poll.choices.first.description
+    assert_equal 'Bar', posts(:not_funny_post).poll.choices.last.description
+  end
+  
+  def test_update_poll_with_no_choices_should_delete_poll
+    assert posts(:funny_post).create_poll({:question => 'Who can have a great time?'}, ['I can', 'You can', 'No one can'])
+
+    assert_difference Poll, :count, -1 do
+      assert posts(:funny_post).update_poll({:question => 'Who can have a terrible time?'}, [])
+    end
+  end  
+  
+  def test_should_find_most_commented
+    assert_equal posts(:funny_post).id, Post.find_most_commented.first.id
+    assert_equal posts(:apt_post).id, Post.find_most_commented.last.id        
+  end
+
+  def test_find_recent
+    assert Post.find_recent(:limit => 30)
+  end
+  
+  def test_image_for_excerpt_for_post_with_no_image_returns_avatar_url
+    assert_equal posts(:funny_post).user.avatar_photo_url(:medium), posts(:funny_post).image_for_excerpt
+  end
+  
+  def test_has_been_favorited_by_user
+    post  = posts(:funny_post)
+    assert !post.has_been_favorited_by(users(:quentin))
+
+    favorite = Favorite.new(:ip_address => '1.1.1.1', :favoritable => post )
+    favorite.user = users(:quentin)
+    favorite.save
+    
+    assert post.has_been_favorited_by(users(:quentin))    
+  end
+  
+  def test_should_set_published_at_date_when_first_published
+    post = users(:quentin).posts.new(:raw_post => 'Blog post message', :title => 'Title')
+    assert !post.published_at
+    post.save!
+    
+    post.published_as = 'live'
+    post.save
+    assert post.published_at
+  end
+  
+  def test_should_not_set_published_at_if_republishing  
+    post = users(:quentin).posts.create!(:raw_post => 'Blog post message', :title => 'Title')
+    post.save_as_live #publish
+    published_at = post.published_at
+    
+    post.save_as_draft #unpublish
+    post.save_as_live #publish again
+    assert_equal post.published_at, published_at
+  end
+  
+  def test_should_show_published_at_display
+    post = posts(:funny_post)
+    assert_equal post.published_at_display, I18n.l(post.published_at, :format => :published_date)
+  end
+
+  def test_should_show_published_at_display_for_draft
+    post = posts(:funny_post)
+    post.save_as_draft
+    assert_equal post.published_at_display, 'Draft'
+  end
+  
+  def test_should_not_notify_for_posts_without_comment_notification_on
+    post = posts(:funny_post)
+    post.send_comment_notifications = false
+    post.save!
+    
+    assert_difference ActionMailer::Base.deliveries, :length, 0 do    
+      comment = post.comments.create!(:comment => 'foo', :user => users(:aaron))
+      comment.send_notifications      
+    end
+    
+  end
+
+  test "should find related" do
+    p1 = posts(:funny_post)
+    p2 = posts(:not_funny_post)
+    
+    p1.tag_list = 'tag1, tag2'
+    p1.save!
+    p2.tag_list = 'tag2, tag3'
+    p2.save!
+    
+    assert Post.find_related_to(p1).include?(p2)
+
+    p2.tag_list = 'tag3, tag4'
+    p2.save!
+
+    assert !Post.find_related_to(p1).include?(p2)    
+
+    
+  end
+      
+end

data/test/unit/rsvp_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class RsvpTest < ActiveSupport::TestCase
+  
+  fixtures :events, :users
+
+  def test_should_be_invalid_with_invalid_attendees_count
+    event = events(:future_event)
+    user = users(:quentin)
+    ['',0,-1,3.5].each do |c|
+      assert_no_difference Rsvp, :count do
+        rsvp = Rsvp.new(:attendees_count=>c)
+        rsvp.event = event
+        rsvp.user = user
+        rsvp.save
+        assert rsvp.errors[:attendees_count]
+      end
+    end    
+  end
+
+  def test_should_be_invalid_with_event_that_does_not_allow_rsvp
+    event = events(:no_rsvp_event)
+    user = users(:quentin)
+    assert_no_difference Rsvp, :count do
+      rsvp = Rsvp.new(:attendees_count=>1)
+      rsvp.event = event
+      rsvp.user = user
+      rsvp.save
+      assert rsvp.errors[:base]
+    end    
+  end
+
+end

data/test/unit/sb_post_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+class SbPostTest < ActiveSupport::TestCase
+  all_fixtures
+  include ActionDispatch::TestProcess
+
+    def test_should_find_topic
+    assert_equal topics(:pdi), sb_posts(:pdi_reply).topic
+  end
+
+  def test_should_require_body_for_post
+    p = topics(:pdi).sb_posts.build
+    p.valid?
+    assert p.errors[:body]
+  end
+
+  def test_should_create_reply
+    counts = lambda { [SbPost.count, forums(:rails).sb_posts_count, users(:aaron).sb_posts_count, topics(:pdi).sb_posts_count] }
+    equal  = lambda { [forums(:rails).topics_count] }
+    old_counts = counts.call
+    old_equal  = equal.call
+    
+    p = create_post topics(:pdi), :body => 'blah'
+    assert p.valid?
+
+    [forums(:rails), users(:aaron), topics(:pdi)].each &:reload
+    
+    assert_equal old_counts.collect { |n| n + 1}, counts.call
+    assert_equal old_equal, equal.call
+  end
+
+  def test_should_update_cached_data
+    p = create_post topics(:pdi), :body => 'ok, ill get right on it'
+    assert p.valid?
+    topics(:pdi).reload
+    assert_equal p.id, topics(:pdi).last_post_id
+    assert_equal p.user_id, topics(:pdi).replied_by
+    assert_equal p.created_at.to_i, topics(:pdi).replied_at.to_i
+  end
+
+  def test_should_delete_last_post_and_fix_topic_cached_data
+    sb_posts(:pdi_rebuttal).destroy
+    assert_equal sb_posts(:pdi_reply).id, topics(:pdi).last_post_id
+    assert_equal sb_posts(:pdi_reply).user_id, topics(:pdi).replied_by
+    assert_equal sb_posts(:pdi_reply).created_at.to_i, topics(:pdi).replied_at.to_i
+  end
+
+  def test_should_create_reply_and_set_forum_from_topic
+    p = create_post topics(:pdi), :body => 'blah'
+    assert_equal topics(:pdi).forum_id, p.forum_id
+  end
+
+  def test_should_delete_reply
+    counts = lambda { [SbPost.count, forums(:rails).sb_posts_count, users(:sam).sb_posts_count, topics(:pdi).sb_posts_count] }
+    equal  = lambda { [forums(:rails).topics_count] }
+    old_counts = counts.call
+    old_equal  = equal.call
+    sb_posts(:pdi_reply).destroy
+    [forums(:rails), users(:sam), topics(:pdi)].each &:reload
+    assert_equal old_counts.collect { |n| n - 1}, counts.call
+    assert_equal old_equal, equal.call
+  end
+
+  def test_should_edit_own_post
+    assert sb_posts(:shield).editable_by?(users(:sam))
+  end
+
+  def test_should_edit_post_as_admin
+    assert sb_posts(:shield).editable_by?(users(:admin))
+  end
+
+  def test_should_edit_post_as_moderator
+    assert sb_posts(:pdi).editable_by?(users(:sam))
+  end
+
+  def test_should_not_edit_post_in_own_topic
+    assert !sb_posts(:shield_reply).editable_by?(users(:sam))
+  end
+  
+  def test_should_automatically_monitor_after_creating
+    topic  = topics(:ponies)
+    assert !users(:aaron).monitoring_topic?(topic)
+    p = create_post topic, :body => 'blah'
+    assert users(:aaron).monitoring_topic?(topic)
+  end
+  
+  def test_should_not_monitor_if_already_unmonitored
+    topic = topics(:pdi)
+    user = users(:aaron) 
+    create_post topic, :body => 'foo'      
+    Monitorship.update_all ['active = ?', false], ['user_id = ? and topic_id = ?', user.id, topic.id]            
+    assert !user.monitoring_topic?(topic)
+    
+    p = create_post topic, :body => 'bar'
+    assert !user.monitoring_topic?(topic)    
+  end
+  
+  test "should not monitor for anonymous posts" do
+    configatron.allow_anonymous_forum_posting = true
+    
+    assert_difference Monitorship, :count, 0 do
+      topic = topics(:pdi)
+      topic.sb_posts.create!(:topic => topic, :body => "Ok!", :author_email => 'anon@example.com', :author_ip => "1.2.3.4")      
+    end
+    
+    configatron.allow_anonymous_forum_posting = false    
+  end
+  
+  def test_to_xml
+    #not really testing the output cause it's just calling Rails' to_xml
+    assert sb_posts(:shield_reply).to_xml
+  end
+  
+  def test_should_be_deleted_when_user_destroyed
+    post = sb_posts(:shield_reply)
+    id = post.id
+    post.user.destroy
+    assert !SbPost.exists?(id)
+  end
+
+  test "should not allow anonymous posting" do
+    configatron.allow_anonymous_forum_posting = false    
+    topic = topics(:pdi)      
+    post = topic.sb_posts.create(:topic => topic, :body => "Ok!", :author_email => 'anon@example.com', :author_ip => "1.2.3.4")
+    assert !post.valid?
+    assert post.errors[:user_id]
+  end
+  
+  test "should allow anonymous posting if configatron specifies it's ok" do
+    configatron.allow_anonymous_forum_posting = true
+    
+    topic = topics(:pdi)
+      
+    assert topic.sb_posts.create!(:topic => topic, :body => "Ok!", :author_email => 'anon@example.com', :author_ip => "1.2.3.4")
+    
+    configatron.allow_anonymous_forum_posting = false    
+  end
+  
+  test "should tranform body before saving" do
+    body = "<script type='text/javascript'>alert('xss attack!')</script> I hacked you!"    
+    post = create_post(topics(:pdi), {:body => body})
+    assert !post.reload.body.include?("<script")
+  end
+  
+  protected
+    def create_post(topic, options = {})
+      topic.sb_posts.new(options).tap do |p|
+        p.user = users(:aaron)
+        p.save!
+      end
+    end
+end

data/test/unit/state_test.rb

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

data/test/unit/tag_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TagTest < ActiveSupport::TestCase
+  fixtures :all  
+
+  test "should get popular tags" do
+    popular = Tag.popular
+    assert_equal popular.first['count'], 2
+  end
+  
+  test "should get popular tags of one type" do
+    popular = Tag.popular(20, 'clipping')
+    assert_equal popular.to_a.size, 1
+    assert_equal popular.first['count'], 2
+  end
+  
+  test "should get related tags" do
+    related = tags(:misc).related_tags
+    assert_equal(related, [tags(:general)])
+  end
+  
+end