community_engine 2.0.0.beta1

data/test/unit/authorization_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class AuthorizationTest < ActiveSupport::TestCase
+  fixtures :all  
+  
+  test "should find existing from hash" do
+    auth = Authorization.create_from_hash(auth_hash)    
+    assert_equal(auth.email, 'email@example.com')
+    existing = Authorization.find_or_create_from_hash(auth_hash.merge('user_info' => {'email' => 'changed@example.com'}))
+    assert_equal(auth, existing)
+    assert_equal(existing.email, 'changed@example.com')    
+  end
+  
+  test "should create new Authorization and User from hash" do
+    assert_difference User, :count, 1 do
+      assert_difference Authorization, :count, 1 do
+        Authorization.create_from_hash(auth_hash)
+      end
+    end
+  end
+  
+  test "should create Authorization for existing user with hash" do
+    assert_difference users(:quentin).authorizations, :count, 1 do
+      assert_difference Authorization, :count, 1 do
+        Authorization.create_from_hash(auth_hash, users(:quentin))
+      end      
+    end
+  end
+  
+  test "should allow authorization to be destroyed" do
+    authorization1 = Authorization.create_from_hash(auth_hash, users(:quentin))              
+    authorization2 = Authorization.create_from_hash(auth_hash.merge('provider' => 'facebook'), users(:quentin))                      
+    
+    assert authorization2.destroy
+    assert authorization2.errors[:base].empty?, 'Authorization should have not have an error on :base'    
+  end
+  
+  
+  test "should not allow authorization to be destroyed if it's the only one left and the user would be invalid without it" do
+    authorization = Authorization.create_from_hash(auth_hash, users(:quentin))              
+    authorization.destroy    
+    assert !authorization.errors[:base].empty?, 'Authorization should have an error on :base'
+  end
+  
+  def auth_hash
+    OmniAuth.config.mock_auth[:default].merge({ 'provider' => 'twitter',
+      'uid' => '12345',
+      'user_info' => {
+        'nickname' => 'omniauthuser',
+        'email' => 'email@example.com'        
+      }
+    })
+  end
+
+end

data/test/unit/category_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class CategoryTest < ActiveSupport::TestCase
+  fixtures :categories, :posts
+  
+  def test_get
+    assert_equal Category.get(:questions), categories(:questions)
+    assert_equal Category.get(:how_to), categories(:how_to)    
+    assert_equal Category.get(:inspiration), categories(:inspiration)        
+    assert_equal Category.get(:news), categories(:news)        
+    assert_equal Category.get(:talk), categories(:talk)
+  end
+      
+  def test_should_display_new_post_text
+    c = Category.get(:questions)
+    c.new_post_text = "Ask a question"
+    c.save!
+    assert_equal "Ask a question", Category.get(:questions).display_new_post_text
+  end
+
+
+end

data/test/unit/choice_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class ChoiceTest < ActiveSupport::TestCase
+
+  def test_should_require_poll
+    c = Choice.new
+    assert !c.valid?
+  end
+end

data/test/unit/clipping_image_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class ClippingImageTest < ActiveSupport::TestCase
+  fixtures :clippings, :users, :roles
+  
+  def teardown
+    Asset.destroy_all
+  end
+    
+  def test_should_be_created
+    image = ClippingImage.new(:attachable => clippings(:google))
+    io = image.data_from_url('http://www.google.com/intl/en_ALL/images/logo.gif')            
+    image.asset = io
+    assert image.save!
+  end
+
+end

data/test/unit/clipping_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class ClippingTest < ActiveSupport::TestCase
+  fixtures :clippings, :tags, :taggings, :users, :roles
+
+  def teardown
+    Asset.destroy_all
+  end
+
+  def test_should_require_user_id
+    clipping = Clipping.new
+    assert !clipping.valid?
+    assert clipping.errors[:user]
+  end
+
+  def test_should_find_related_clippings
+    google_clip = clippings(:google)
+    related = Clipping.find_related_to(google_clip)
+    assert_equal [ clippings(:yahoo_related_to_google) ], related
+  end
+
+  def test_should_find_recent
+    clippings = Clipping.find_recent(:limit => 1)
+    assert_equal clippings.size, 1
+  end
+  
+  def test_should_find_previous_clipping
+    previous = clippings(:google).previous_clipping
+    assert_equal previous, clippings(:yahoo_related_to_google)
+  end
+  
+  def test_should_find_next_clipping
+    next_clipping = clippings(:yahoo_related_to_google).next_clipping
+    assert_equal next_clipping, clippings(:google)
+  end
+  
+  def test_should_get_clipping_image
+    assert_difference Asset, :count, 1 do
+      c = Clipping.create(:user => users(:quentin), :url => 'http://example.com', :image_url => 'http://www.google.com/intl/en_ALL/images/logo.gif')
+      c.save!
+    end
+  end
+  
+  def test_should_require_valid_image_url
+    assert_no_difference Clipping, :count do
+      assert_difference Asset, :count, 0 do      
+        c = Clipping.create(:user => users(:quentin), :url => 'http://example.com', :image_url => 'hijack!')    
+      end
+    end
+  end
+  
+end

data/test/unit/comment_test.rb

@@ -0,0 +1,107 @@
+require 'test_helper'
+
+class CommentTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def test_should_find_comments_by_user
+    comments = Comment.find_comments_by_user(users(:quentin))
+    assert !comments.empty?
+  end
+  
+  def test_comment_can_be_deleted_by
+    comment = comments(:aarons_comment_on_quentins_post)
+    assert comment.can_be_deleted_by(users(:aaron))
+    assert comment.can_be_deleted_by(users(:quentin))    
+    assert !comment.can_be_deleted_by(users(:florian))
+  end
+    
+  def test_should_be_created_anonymously    
+    configatron.allow_anonymous_commenting = true
+    assert_difference Comment, :count, 1 do
+      comment = users(:quentin).comments.create!(
+        :comment => 'foo', 
+        :author_email => 'bar@foo.com', 
+        :author_ip => '123.123.123', 
+        :recipient => users(:quentin)
+      )
+    end
+    configatron.allow_anonymous_commenting = false
+  end
+  
+  def test_should_notify_previous_anonymous_commenter
+    configatron.allow_anonymous_commenting = true
+    users(:quentin).comments.create!(:comment => 'foo', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))
+    users(:quentin).comments.create!(:comment => 'bar', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))    
+
+    comment = users(:quentin).comments.create!(:comment => 'bar', :author_email => 'alicia@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))        
+
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      comment.notify_previous_anonymous_commenters
+    end
+    configatron.allow_anonymous_commenting = false
+  end  
+  
+  def test_should_not_notify_previous_anonymous_commenter_if_self
+    configatron.allow_anonymous_commenting = true
+    users(:quentin).comments.create!(:comment => 'foo', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))
+    users(:quentin).comments.create!(:comment => 'bar', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))    
+
+    comment = users(:quentin).comments.create!(:comment => 'bar', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))        
+
+    assert_difference ActionMailer::Base.deliveries, :length, 0 do
+      comment.notify_previous_anonymous_commenters
+    end
+    configatron.allow_anonymous_commenting = nil
+  end  
+  
+  def test_should_not_notify_previous_anonymous_commenter_if_notify_by_email_is_false
+    configatron.allow_anonymous_commenting = true
+    users(:quentin).comments.create!(:comment => 'foo', :author_email => 'bruno@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin), :notify_by_email => false)
+
+    comment = users(:quentin).comments.create!(:comment => 'bar', :author_email => 'alicia@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))        
+
+    assert_difference ActionMailer::Base.deliveries, :length, 0 do
+      comment.notify_previous_anonymous_commenters
+    end
+    configatron.allow_anonymous_commenting = false
+  end
+  
+  def test_should_not_be_created_anonymously
+    assert_no_difference Comment, :count do
+      comment = users(:quentin).comments.create(:comment => 'foo', :author_email => 'bar@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin))
+    end
+  end
+  
+  def test_should_be_created_without_recipient
+    assert_difference Comment, :count, 1 do
+      comment = users(:aaron).comments.create!(:comment => 'foo', :user => users(:quentin))
+    end  
+  end
+
+  def test_should_unsubscribe_notifications
+    configatron.allow_anonymous_commenting = true
+    first_comment = users(:quentin).comments.create!(:comment => 'foo', :author_email => 'alicia@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin), :notify_by_email => true)        
+    comment = users(:quentin).comments.create!(:comment => 'bar', :author_email => 'alicia@foo.com', :author_ip => '123.123.123', :recipient => users(:quentin), :notify_by_email => true)        
+    assert_equal first_comment.notify_by_email, true
+    assert_equal comment.notify_by_email, true
+    configatron.allow_anonymous_commenting = false    
+    
+    comment.unsubscribe_notifications('alicia@foo.com')
+    assert comment.reload.notify_by_email.eql?(false)
+    assert first_comment.reload.notify_by_email.eql?(false)
+  end
+  
+  def test_should_not_notify_of_comments_on_post_with_send_notifications_off
+    post = posts(:funny_post)
+    post.send_comment_notifications = false
+    post.save!
+
+    comment = post.comments.create!(:comment => 'foo', :user => users(:aaron), :recipient => users(:quentin))
+    assert_difference ActionMailer::Base.deliveries, :length, 0 do        
+      comment.send_notifications      
+    end
+  end
+
+
+end
+  

data/test/unit/country_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class CountryTest < ActiveSupport::TestCase
+  fixtures :countries, :metro_areas
+
+  def test_should_find_united_states
+    country = Country.get(:us)
+    assert !country.nil?
+  end
+  
+  def test_should_find_countries_with_metro_areas
+    c = Country.find_countries_with_metros
+    assert_equal c.size, 3
+  end
+end

data/test/unit/event_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class EventTest < ActiveSupport::TestCase
+  
+  fixtures :events
+
+  def test_should_be_invalid_without_name
+    assert_no_difference Event, :count do
+      u = Event.new(valid_event_attributes.except(:name))
+      u.save
+      assert u.errors[:name]
+    end    
+  end
+
+  def test_should_be_invalid_without_date
+    assert_no_difference Event, :count do
+      u = Event.new(valid_event_attributes.except(:start_time))
+      u.save
+      assert u.errors[:start_time]
+    end    
+  end
+  
+  def test_should_be_invalid_without_name
+    assert_no_difference Event, :count do
+      u = Event.new(valid_event_attributes.except(:user))
+      u.save
+      assert u.errors[:user]
+    end    
+  end  
+  
+  def test_should_be_invalid_if_start_time_is_after_end_time
+    assert_no_difference Event, :count do
+      u = Event.new(valid_event_attributes.merge(:start_time => Time.now, :end_time => 1.week.ago))
+      u.save
+      assert u.errors[:start_time]
+    end    
+  end
+
+  def test_upcoming_event_scope_should_only_find_future_events
+    future_events = Event.upcoming.all
+    assert_equal future_events.size, 3
+    future_events.each {|e| assert e.end_time > Time.now}
+  end
+
+  def test_past_event_scope_should_only_find_old_events
+    past_events = Event.past.all
+    assert_equal past_events.size, 3
+    past_events.each {|e| assert e.end_time <= Time.now}
+  end
+
+  def test_upcoming_events_shown_asc_order
+    future_events = Event.upcoming.find(:all)
+    assert_equal future_events.first, events(:future_event)
+    assert_equal future_events.second, events(:further_future_event) 
+  end
+
+  def test_past_events_shown_desc_order
+    future_events = Event.past.find(:all)
+    assert_equal future_events.first, events(:past_event)
+    assert_equal future_events.second, events(:cool_event)
+    assert_equal future_events.third, events(:further_past_event) 
+  end  
+
+  protected
+  def valid_event_attributes
+    {:name => 'A great event',
+      :user => User.new,
+      :start_time => 1.week.ago,
+      :end_time => 4.days.ago,      
+      :description => 'This will be fun',
+      :metro_area => MetroArea.new
+    }
+  end
+
+end

data/test/unit/favorite_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class FavoriteTest < ActiveSupport::TestCase
+  fixtures :clippings, :users, :roles
+  
+  def setup
+    Favorite.destroy_all
+  end
+  
+  def test_should_be_created
+    f = Favorite.new(:favoritable => clippings(:google), :ip_address => '127.0.0.1')
+    assert f.save!
+  end
+  
+  def test_should_be_invalid_without_favoritable
+    f = Favorite.new(:ip_address => '127.0.0.1')
+    assert !f.valid?
+    assert f.errors[:favoritable]
+  end
+  
+  def test_should_update_counter_on_clipping
+    f = Favorite.new(:favoritable => clippings(:google), :ip_address => '127.0.0.1')
+    f2 = Favorite.new(:favoritable => clippings(:google), :ip_address => '127.0.0.2')
+    assert_difference clippings(:google), :favorited_count, 2 do
+      f.save!
+      f2.save!
+    end
+  end
+  
+  def test_should_decrease_counter_when_destroyed
+    f = Favorite.new(:favoritable => clippings(:google), :ip_address => '127.0.0.1')
+    f.save!    
+    
+    assert_difference clippings(:google), :favorited_count, -1 do
+      f.destroy
+    end
+  end  
+  
+  def test_same_user_should_not_favorite_twice
+    Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1', :user => users(:quentin))
+
+    assert_raise ActiveRecord::RecordInvalid do  
+      Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1', :user => users(:quentin))        
+    end
+
+  end
+
+  def test_same_ip_address_should_not_favorite_twice
+    Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1')
+
+    assert_raise ActiveRecord::RecordInvalid do  
+      Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1')        
+    end
+  end
+
+  def test_should_find_by_remote_ip
+    Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1')
+    assert Favorite.find_by_user_or_ip_address(clippings(:google), nil, '127.0.0.1')    
+  end
+
+  def test_should_find_by_user_or_ip
+    Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1', :user => users(:quentin))
+    assert Favorite.find_by_user_or_ip_address(clippings(:google), users(:quentin))    
+  end
+
+  def test_should_find_favorites_by_user
+    favorite = Favorite.create!(:favoritable => clippings(:google), :ip_address => '127.0.0.1', :user => users(:quentin))
+    assert Favorite.find_favorites_by_user(users(:quentin)).include?(favorite)
+  end
+
+end

data/test/unit/forum_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class ForumTest < ActiveSupport::TestCase
+  fixtures :all
+
+  def test_should_list_only_top_level_topics
+    assert_equal [topics(:sticky), topics(:il8n), topics(:ponies), topics(:pdi)], forums(:rails).topics.order('sticky DESC, created_at DESC').all
+  end
+
+  def test_should_find_first_recent_post
+    assert_equal topics(:il8n), forums(:rails).topics.recently_replied.first
+  end
+
+  def test_should_format_body_html
+    forum = Forum.new(:description => 'foo')
+    forum.send :format_content
+    assert_not_nil forum.description_html
+    
+    forum.description = ''
+    forum.send :format_content
+    assert forum.description_html.blank?
+  end
+end

data/test/unit/friendship_status_test.rb

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

data/test/unit/friendship_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class FriendshipTest < ActiveSupport::TestCase
+  fixtures :friendships, :users, :roles, :friendship_statuses 
+
+  def test_user_and_friend_can_not_be_same
+    fr = Friendship.new(:user_id => 1, :friend_id => 1)
+    assert(!fr.valid?, "Friendship should not be valid")
+    assert fr.errors[:user_id]
+  end
+  
+  def test_should_prevent_overzealous_frienders
+    Friendship.daily_request_limit = 2    
+    
+    assert Friendship.create!(:user_id => 1, :friend_id => 3, :friendship_status => FriendshipStatus[:pending], :initiator => true)
+    assert Friendship.create!(:user_id => 1, :friend_id => 4, :friendship_status => FriendshipStatus[:pending], :initiator => true)
+    
+    f3 = Friendship.create(:user_id => 1, :friend_id => 5, :friendship_status => FriendshipStatus[:pending], :initiator => true)
+    assert(!f3.valid?, "Friendship should not be valid")
+    assert_equal f3.errors[:base], ["Sorry, you'll have to wait a little while before requesting any more friendships."]
+  end
+  
+  def test_should_notify_requester_when_accepted
+    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_not_notify_requester_when_pending
+    f = friendships(:aaron_receive_quentin_pending)    
+    assert_difference ActionMailer::Base.deliveries, :length, 0 do
+      f.update_attributes(:friendship_status => FriendshipStatus[:pending]) && f.reverse.update_attributes(:friendship_status => FriendshipStatus[:pending])    
+    end        
+  end
+
+
+end

data/test/unit/homepage_feature_test.rb

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

data/test/unit/invitation_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class InvitationTest < ActiveSupport::TestCase
+  fixtures :invitations, :users, :roles
+
+  def test_email_addresses_validation
+    addresses = "valid@example.com, valid_2@example.com, invalid.invalid.com"
+    invitation = Invitation.new(:email_addresses => addresses)
+    assert !invitation.valid?
+    assert invitation.errors[:email_addresses]
+  end
+  
+  def test_send_with_names_in_emails
+    addresses = '"Valid Example" <valid@example.com>, valid_2@example.com'
+    invitation = Invitation.new(:email_addresses => addresses, :user => users(:quentin))
+    assert invitation.valid?
+    assert invitation.send_invite    
+  end
+  
+  def test_send_invite
+    addresses = "valid@example.com, valid_2@example.com"
+    invitation = Invitation.new(:email_addresses => addresses, :user => users(:quentin))
+    assert invitation.valid?
+    assert invitation.send_invite
+  end
+
+end

data/test/unit/message_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class MessageTest < ActiveSupport::TestCase
+  fixtures :all
+
+  test "should be created" do
+    message = Message.create!(:sender => users(:quentin), :recipient => users(:aaron), :body => 'hey aaron', :subject => 'Hello friend!')    
+  end
+
+  def test_should_send_notification
+    assert_difference ActionMailer::Base.deliveries, :length, 1 do
+      message = Message.create!(:sender => users(:quentin), :recipient => users(:aaron), :body => 'hey aaron', :subject => 'Hello friend!')
+    end
+  end
+  
+  def test_should_be_invalid_without_subject
+    m = Message.new(:subject => nil)
+    assert !m.valid?
+    assert m.errors[:subject]
+  end
+
+  def test_should_be_invalid_without_body
+    m = Message.new(:body => nil)
+    assert !m.valid?
+    assert m.errors[:body]
+  end
+  
+  def test_should_be_invalid_without_recipient
+    m = Message.new(:recipient => nil)
+    assert !m.valid?
+    assert m.errors[:recipient]
+  end
+  
+  def test_should_not_allow_message_to_self
+    m = Message.new(:sender => users(:quentin), :recipient => users(:quentin))
+    assert !m.valid?
+    assert m.errors[:base]
+  end
+  
+  def test_should_be_deleted_with_user
+    message = Message.create!(:sender => users(:quentin), :recipient => users(:aaron), :body => 'hey aaron', :subject => 'Hello friend!')    
+  
+    assert_difference Message, :count, -1 do
+      users(:quentin).destroy
+    end
+  end
+
+
+end

data/test/unit/message_thread_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class MessageThreadTest < ActiveSupport::TestCase
+  fixtures :all
+  
+  test "subject should equal parent message subject" do
+    message_thread = MessageThread.new(:parent_message => messages(:message_from_kevin_to_aaron))
+    assert_equal(message_thread.subject, messages(:message_from_kevin_to_aaron).subject)
+  end
+  
+  test "creator_name should be parent message's sender login " do
+    message_thread = MessageThread.new(:parent_message => messages(:message_from_kevin_to_aaron), :recipient => users(:aaron), :sender => users(:kevin))    
+    assert_equal(message_thread.creator_name, users(:kevin).login )
+  end
+
+  test "creator_name should be 'Me' when sender parent message sender is recipient " do
+    message_thread = MessageThread.new(:parent_message => messages(:message_from_kevin_to_aaron), :recipient => users(:kevin), :sender => users(:aaron))    
+    assert_equal(message_thread.creator_name, 'Me' )
+  end
+  
+  test "should find MessageThread for a particular message and user" do
+    messages(:message_from_kevin_to_aaron).update_message_threads
+    aarons_thread = messages(:message_from_kevin_to_aaron).message_threads.first
+    
+    message_thread = MessageThread.for(messages(:message_from_kevin_to_aaron), users(:aaron))
+    assert_equal message_thread, aarons_thread
+  end
+  
+  test "should mark recipient's messages as deleted when destroyed" do
+    messages(:message_from_kevin_to_aaron).update_message_threads
+    aarons_thread = messages(:message_from_kevin_to_aaron).message_threads.first
+    
+    aarons_thread.destroy
+    assert aarons_thread.parent_message.recipient_deleted
+    assert !aarons_thread.parent_message.sender_deleted    
+  end
+
+  test "should mark sender's messages as deleted when destroyed" do
+    message = messages(:message_from_kevin_to_aaron)
+    message.update_message_threads
+    message_thread = MessageThread.for(message, users(:aaron))
+    
+    # create a reply from aaron to kevin's message
+    reply = Message.new_reply(users(:aaron), message_thread, {:message => { :body => 'Hey kevin, just replying to your message'}})    
+    reply.recipient = users(:kevin)
+    reply.save!
+
+    kevins_thread = MessageThread.for(reply, users(:kevin))
+    kevins_thread.destroy
+    
+    #Parent message was sent by kevin, should be deleted by kevin and not by aaron
+    assert kevins_thread.parent_message.sender_deleted, 'The parent message should be marked as deleted for by sender'
+    assert !kevins_thread.parent_message.recipient_deleted, 'The parent message should not be marked as deleted by the recipient'    
+
+    #Child message was sent by aaron, should be deleted by kevin and not by aaron. Whew.
+    assert kevins_thread.parent_message.children.first.recipient_deleted, 'The child message should be deleted by the recipient'
+    assert !kevins_thread.parent_message.children.first.sender_deleted, 'The child message should not be marked as deleted by the sender'
+  end
+
+  test "read? should always be 'read' for the sender" do
+    message = messages(:message_from_kevin_to_aaron)
+    message.update_message_threads
+
+    aarons_thread = MessageThread.for(message, users(:aaron))
+    assert_equal aarons_thread.read?, false 
+  
+    # create a reply from aaron to kevin's message
+    reply = Message.new_reply(users(:aaron), aarons_thread, {:message => { :body => 'Hey kevin, just replying to your message'}})    
+    reply.recipient = users(:kevin)
+    reply.save!
+    
+    aarons_thread = MessageThread.for(reply, users(:aaron))    
+
+    assert_equal aarons_thread.read?, 'read'
+
+    
+  end
+
+
+end