has_messages_huacnlee 0.4.1 → 0.4.2

data/test/app_root/app/models/user.rb

@@ -1,3 +0,0 @@
-class User < ActiveRecord::Base
-  has_messages
-end

data/test/app_root/config/environment.rb

@@ -1,9 +0,0 @@
-require 'config/boot'
-
-Rails::Initializer.run do |config|
-  config.plugin_paths << '..'
-  config.plugins = %w(state_machine has_messages)
-  config.cache_classes = false
-  config.whiny_nils = true
-  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
-end

data/test/app_root/db/migrate/001_create_users.rb

@@ -1,11 +0,0 @@
-class CreateUsers < ActiveRecord::Migration
-  def self.up
-    create_table :users do |t|
-      t.string :login, :null => false
-    end
-  end
-
-  def self.down
-    drop_table :users
-  end
-end

data/test/app_root/db/migrate/002_migrate_has_messages_to_version_2.rb

@@ -1,13 +0,0 @@
-class MigrateHasMessagesToVersion2 < ActiveRecord::Migration
-  def self.up
-    ActiveRecord::Migrator.new(:up, "#{Rails.root}/../../generators/has_messages/templates", 0).migrations.each do |migration|
-      migration.migrate(:up)
-    end
-  end
-  
-  def self.down
-    ActiveRecord::Migrator.new(:down, "#{Rails.root}/../../generators/has_messages/templates", 0).migrations.each do |migration|
-      migration.migrate(:down)
-    end
-  end
-end

data/test/factory.rb

@@ -1,58 +0,0 @@
-module Factory
-  # Build actions for the model
-  def self.build(model, &block)
-    name = model.to_s.underscore
-    
-    define_method("#{name}_attributes", block)
-    define_method("valid_#{name}_attributes") {|*args| valid_attributes_for(model, *args)}
-    define_method("new_#{name}")              {|*args| new_record(model, *args)}
-    define_method("create_#{name}")           {|*args| create_record(model, *args)}
-  end
-  
-  # Get valid attributes for the model
-  def valid_attributes_for(model, attributes = {})
-    name = model.to_s.underscore
-    send("#{name}_attributes", attributes)
-    attributes.stringify_keys!
-    attributes
-  end
-  
-  # Build an unsaved record
-  def new_record(model, *args)
-    attributes = valid_attributes_for(model, *args)
-    record = model.new(attributes)
-    attributes.each {|attr, value| record.send("#{attr}=", value) if model.accessible_attributes && !model.accessible_attributes.include?(attr) || model.protected_attributes && model.protected_attributes.include?(attr)}
-    record
-  end
-  
-  # Build and save/reload a record
-  def create_record(model, *args)
-    record = new_record(model, *args)
-    record.save!
-    record.reload
-    record
-  end
-  
-  build Message do |attributes|
-    attributes[:sender] = create_user unless attributes.include?(:sender)
-    attributes.reverse_merge!(
-      :subject => 'New features',
-      :body => 'Lots of new things to talk about... come to the meeting tonight to find out!',
-      :created_at => Time.current + Message.count
-    )
-  end
-  
-  build MessageRecipient do |attributes|
-    attributes[:message] = create_message unless attributes.include?(:message)
-    attributes[:receiver] = create_user(:login => 'me') unless attributes.include?(:receiver)
-    attributes.reverse_merge!(
-      :kind => 'to'
-    )
-  end
-  
-  build User do |attributes|
-    attributes.reverse_merge!(
-      :login => 'admin'
-    )
-  end
-end

data/test/functional/has_messages_test.rb

@@ -1,140 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class UserByDefaultTest < ActiveSupport::TestCase
-  def setup
-    @user = create_user
-  end
-  
-  def test_should_not_have_any_messages
-    assert @user.messages.empty?
-  end
-  
-  def test_should_not_have_any_unsent_messages
-    assert @user.unsent_messages.empty?
-  end
-  
-  def test_should_not_have_any_sent_messages
-    assert @user.sent_messages.empty?
-  end
-  
-  def test_should_not_have_any_received_messages
-    assert @user.received_messages.empty?
-  end
-end
-
-class UserTest < ActiveSupport::TestCase
-  def setup
-    @user = create_user
-  end
-  
-  def test_should_be_able_to_create_new_messages
-    message = @user.messages.build
-    assert_instance_of Message, message
-    assert_equal @user, message.sender
-  end
-  
-  def test_should_be_able_to_send_new_messages
-    message = @user.messages.build
-    message.to create_user(:login => 'John')
-    assert message.deliver
-  end
-end
-
-class UserWithUnsentMessages < ActiveSupport::TestCase
-  def setup
-    @user = create_user
-    @sent_message = create_message(:sender => @user, :to => create_user(:login => 'you'))
-    @sent_message.deliver
-    @first_draft = create_message(:sender => @user)
-    @second_draft = create_message(:sender => @user)
-  end
-  
-  def test_should_have_unsent_messages
-    assert_equal [@second_draft, @first_draft], @user.unsent_messages
-  end
-  
-  def test_should_include_unsent_messages_in_messages
-    assert_equal [@second_draft, @first_draft, @sent_message], @user.messages
-  end
-end
-
-class UserWithSentMessages < ActiveSupport::TestCase
-  def setup
-    @user = create_user
-    @to = create_user(:login => 'you')
-    @draft = create_message(:sender => @user)
-    @draft.save!
-    
-    @first_sent_message = create_message(:sender => @user, :to => @to)
-    @first_sent_message.deliver
-    
-    @second_sent_message = create_message(:sender => @user, :to => @to)
-    @second_sent_message.deliver
-  end
-  
-  def test_should_have_sent_messages
-    assert_equal [@second_sent_message, @first_sent_message], @user.sent_messages
-  end
-  
-  def test_should_include_sent_messages_in_messages
-    assert_equal [@second_sent_message, @first_sent_message, @draft], @user.messages
-  end
-end
-
-class UserWithReceivedMessages < ActiveSupport::TestCase
-  def setup
-    @sender = create_user
-    @user = create_user(:login => 'me')
-    
-    @unsent_message = create_message(:sender => @sender, :to => @user)
-    
-    @first_sent_message = create_message(:sender => @sender, :to => @user)
-    @first_sent_message.deliver
-    
-    @second_sent_message = create_message(:sender => @sender, :to => @user)
-    @second_sent_message.deliver
-  end
-  
-  def test_should_have_received_messages
-    assert_equal [@second_sent_message, @first_sent_message], @user.received_messages.map(&:message)
-  end
-end
-
-class UserWithHiddenMessagesTest < ActiveSupport::TestCase
-  def setup
-    @user = create_user
-    @friend = create_user(:login => 'you')
-    
-    hidden_unsent_message = create_message(:sender => @user)
-    hidden_unsent_message.hide
-    @unsent_message = create_message(:sender => @user)
-    
-    hidden_sent_message = create_message(:sender => @user, :to => @friend)
-    hidden_sent_message.deliver
-    hidden_sent_message.hide
-    @sent_message = create_message(:sender => @user, :to => @friend)
-    @sent_message.deliver
-    
-    hidden_received_message = create_message(:sender => @friend, :to => @user)
-    hidden_received_message.deliver
-    hidden_received_message.recipients.first.hide
-    @received_message = create_message(:sender => @friend, :to => @user)
-    @received_message.deliver
-  end
-  
-  def test_should_not_include_hidden_messages_in_messages
-    assert_equal [@sent_message, @unsent_message], @user.messages
-  end
-  
-  def test_should_not_include_hidden_messages_in_unsent_messages
-    assert_equal [@unsent_message], @user.unsent_messages
-  end
-  
-  def test_should_not_include_hidden_messages_in_sent_messages
-    assert_equal [@sent_message], @user.sent_messages
-  end
-  
-  def test_should_not_include_hidden_messages_in_received_messages
-    assert_equal [@received_message], @user.received_messages.map(&:message)
-  end
-end

data/test/test_helper.rb

@@ -1,13 +0,0 @@
-# Load the plugin testing framework
-$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
-require 'rubygems'
-require 'plugin_test_helper'
-
-# Run the migrations
-ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
-
-# Mixin the factory helper
-require File.expand_path("#{File.dirname(__FILE__)}/factory")
-Test::Unit::TestCase.class_eval do
-  include Factory
-end

data/test/unit/message_recipient_test.rb

@@ -1,449 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class MessageRecipientByDefaultTest < ActiveSupport::TestCase
-  def setup
-    @recipient = MessageRecipient.new
-  end
-  
-  def test_should_not_have_a_message
-    assert_nil @recipient.message_id
-  end
-  
-  def test_should_not_have_a_receiver_id
-    assert_nil @recipient.receiver_id
-  end 
-  
-  def test_should_not_have_a_receiver_type
-    assert @recipient.receiver_type.blank?
-  end
-  
-  def test_should_not_have_a_kind
-    assert @recipient.kind.blank?
-  end
-  
-  def test_should_not_have_a_position
-    assert_nil @recipient.position
-  end
-  
-  def test_should_be_in_the_unread_state
-    assert_equal 'unread', @recipient.state
-  end
-  
-  def test_should_not_be_hidden
-    assert_nil @recipient.hidden_at
-    assert !@recipient.hidden?
-  end
-end
-
-class MesageRecipientTest < ActiveSupport::TestCase
-  def test_should_be_valid_with_a_set_of_valid_attributes
-    recipient = new_message_recipient
-    assert recipient.valid?
-  end
-  
-  def test_should_require_a_message
-    recipient = new_message_recipient(:message => nil)
-    assert !recipient.valid?
-    assert recipient.errors.invalid?(:message_id)
-  end
-  
-  def test_should_require_a_kind
-    recipient = new_message_recipient(:kind => nil)
-    assert !recipient.valid?
-    assert recipient.errors.invalid?(:kind)
-  end
-  
-  def test_should_require_a_state
-    recipient = new_message_recipient(:state => nil)
-    assert !recipient.valid?
-    assert recipient.errors.invalid?(:state)
-  end
-  
-  def test_should_require_a_receiver_id
-    recipient = new_message_recipient(:receiver => nil)
-    assert !recipient.valid?
-    assert recipient.errors.invalid?(:receiver_id)
-  end
-  
-  def test_should_require_a_receiver_type
-    recipient = new_message_recipient(:receiver => nil)
-    assert !recipient.valid?
-    assert recipient.errors.invalid?(:receiver_type)
-  end
-  
-  def test_should_not_require_a_position
-    recipient = new_message_recipient(:position => nil)
-    assert recipient.valid?
-  end
-  
-  def test_should_protect_attributes_from_mass_assignment
-    recipient = MessageRecipient.new(
-      :id => 1,
-      :message_id => 1,
-      :receiver_id => 1,
-      :receiver_type => 'User',
-      :kind => 'bcc',
-      :position => 10,
-      :state => 'read',
-      :hidden_at => Time.now
-    )
-    
-    assert_nil recipient.id
-    assert_equal 1, recipient.message_id
-    assert_equal 1, recipient.receiver_id
-    assert_equal 'User', recipient.receiver_type
-    assert_equal 'bcc', recipient.kind
-    assert_nil recipient.position
-    assert_equal 'unread', recipient.state
-    assert_nil recipient.hidden_at
-  end
-end
-
-class MessageRecipientAfterBeingCreatedTest < ActiveSupport::TestCase
-  def setup
-    @admin = create_user(:login => 'admin')
-    @erich = create_user(:login => 'Erich')
-    @richard = create_user(:login => 'Richard')
-    @ralph = create_user(:login => 'Ralph')
-    
-    message = create_message(
-      :subject => 'Hello',
-      :body => 'How are you?',
-      :sender => @admin,
-      :cc => @richard,
-      :bcc => @ralph
-    )
-    @recipient = create_message_recipient(
-      :message => message,
-      :receiver => @erich,
-      :kind => 'to'
-    )
-  end
-  
-  def test_should_not_be_hidden
-    assert !@recipient.hidden?
-  end
-  
-  def test_should_delegate_sender_to_message
-    assert_equal @admin, @recipient.sender
-  end
-  
-  def test_should_delegate_subject_to_message
-    assert_equal 'Hello', @recipient.subject
-  end
-  
-  def test_should_delegate_body_to_message
-    assert_equal 'How are you?', @recipient.body
-  end
-  
-  def test_should_delegate_recipients_to_message
-    assert_equal [@erich, @richard, @ralph], @recipient.recipients.map(&:receiver)
-  end
-  
-  def test_should_delegate_to_receivers_to_message
-    assert_equal [@erich], @recipient.to
-  end
-  
-  def test_should_delegate_cc_receivers_to_message
-    assert_equal [@richard], @recipient.cc
-  end
-  
-  def test_should_delegate_bcc_receivers_to_message
-    assert_equal [@ralph], @recipient.bcc
-  end
-  
-  def test_should_delegate_created_at_to_message
-    assert_not_nil @recipient.created_at
-  end
-end
-
-class MessageRecipientOfMultipleTest < ActiveSupport::TestCase
-  def setup
-    @erich = create_user(:login => 'Erich')
-    @richard = create_user(:login => 'Richard')
-    @ralph = create_user(:login => 'Ralph')
-    
-    message = create_message(:to => [@erich, @richard])
-    @recipient = create_message_recipient(
-      :message => message,
-      :receiver => @ralph,
-      :kind => 'to'
-    )
-  end
-  
-  def test_should_use_position_based_on_position_of_last_recipient
-    assert_equal 3, @recipient.position
-  end
-end
-
-class MessageRecipientUnreadWithUnsentMessageTest < ActiveSupport::TestCase
-  def setup
-    @recipient = create_message_recipient
-  end
-  
-  def test_should_be_in_the_unread_state
-    assert_equal 'unread', @recipient.state
-  end
-  
-  def test_should_not_be_able_to_view
-    assert !@recipient.view
-  end
-end
-
-class MessageRecipientUnreadWithSentMessageTest < ActiveSupport::TestCase
-  def setup
-    @recipient = create_message_recipient
-    @recipient.message.deliver
-  end
-  
-  def test_should_be_in_the_unread_state
-    assert_equal 'unread', @recipient.state
-  end
-  
-  def test_should_be_able_to_view
-    assert @recipient.view
-  end
-end
-
-class MessageRecipientReadTest < ActiveSupport::TestCase
-  def setup
-    @recipient = create_message_recipient
-    @recipient.message.deliver
-    @recipient.view
-  end
-  
-  def test_should_be_in_the_read_state
-    assert_equal 'read', @recipient.state
-  end
-  
-  def test_should_not_be_able_to_view
-    assert !@recipient.view
-  end
-end
-
-class MessageRecipientHiddenTest < ActiveSupport::TestCase
-  def setup
-    @recipient = create_message_recipient
-    @recipient.hide
-  end
-  
-  def test_should_record_when_it_was_hidden
-    assert_not_nil @recipient.hidden_at
-  end
-  
-  def test_should_be_hidden
-    assert @recipient.hidden?
-  end
-  
-  def test_should_not_be_visible
-    assert !@recipient.visible?
-  end
-end
-
-class MessageRecipientUnhiddenTest < ActiveSupport::TestCase
-  def setup
-    @recipient = create_message_recipient
-    @recipient.hide
-    @recipient.unhide
-  end
-  
-  def test_should_not_have_the_recorded_value_when_it_was_hidden
-    assert_nil @recipient.hidden_at
-  end
-  
-  def test_should_not_be_hidden
-    assert !@recipient.hidden?
-  end
-  
-  def test_should_be_visible
-    assert @recipient.visible?
-  end
-end
-
-class MessageRecipientForwardedTest < ActiveSupport::TestCase
-  def setup
-    @erich = create_user(:login => 'Erich')
-    original_message = create_message(
-      :subject => 'Hello',
-      :body => 'How are you?',
-      :cc => create_user(:login => 'Richard'),
-      :bcc => create_user(:login => 'Ralph')
-    )
-    @recipient = create_message_recipient(
-      :message => original_message,
-      :receiver => @erich
-    )
-    @message = @recipient.forward
-  end
-  
-  def test_should_be_in_unsent_state
-    assert_equal 'unsent', @message.state
-  end
-  
-  def test_should_not_be_hidden
-    assert !@message.hidden?
-  end
-  
-  def test_should_have_original_subject
-    assert_equal 'Hello', @message.subject
-  end
-  
-  def test_should_have_original_body
-    assert_equal 'How are you?', @message.body
-  end
-  
-  def test_should_use_receiver_as_the_sender
-    assert_equal @erich, @message.sender
-  end
-  
-  def test_should_not_include_to_recipients
-    assert @message.to.empty?
-  end
-  
-  def test_should_not_include_cc_recipients
-    assert @message.cc.empty?
-  end
-  
-  def test_should_not_include_bcc_recipients
-    assert @message.bcc.empty?
-  end
-end
-
-class MessageRecipientRepliedTest < ActiveSupport::TestCase
-  def setup
-    @erich = create_user(:login => 'Erich')
-    @john = create_user(:login => 'John')
-    original_message = create_message(
-      :subject => 'Hello',
-      :body => 'How are you?',
-      :to => @john,
-      :cc => create_user(:login => 'Richard'),
-      :bcc => create_user(:login => 'Ralph')
-    )
-    @recipient = create_message_recipient(
-      :message => original_message,
-      :receiver => @erich
-    )
-    @message = @recipient.reply
-  end
-  
-  def test_should_be_in_unsent_state
-    assert_equal 'unsent', @message.state
-  end
-  
-  def test_should_not_be_hidden
-    assert !@message.hidden?
-  end
-  
-  def test_should_have_original_subject
-    assert_equal 'Hello', @message.subject
-  end
-  
-  def test_should_have_original_body
-    assert_equal 'How are you?', @message.body
-  end
-  
-  def test_should_use_receiver_as_the_sender
-    assert_equal @erich, @message.sender
-  end
-  
-  def test_should_include_to_recipients
-    assert [@erich, @john], @message.to
-  end
-  
-  def test_should_not_include_cc_recipients
-    assert @message.cc.empty?
-  end
-  
-  def test_should_not_include_bcc_recipients
-    assert @message.bcc.empty?
-  end
-end
-
-class MessageRecipientRepliedToAllTest < ActiveSupport::TestCase
-  def setup
-    @erich = create_user(:login => 'Erich')
-    @john = create_user(:login => 'John')
-    @richard = create_user(:login => 'Richard')
-    @ralph = create_user(:login => 'Ralph')
-    original_message = create_message(
-      :subject => 'Hello',
-      :body => 'How are you?',
-      :to => @john,
-      :cc => @richard,
-      :bcc => @ralph
-    )
-    @recipient = create_message_recipient(
-      :message => original_message,
-      :receiver => @erich
-    )
-    @message = @recipient.reply_to_all
-  end
-  
-  def test_should_be_in_unsent_state
-    assert_equal 'unsent', @message.state
-  end
-  
-  def test_should_not_be_hidden
-    assert !@message.hidden?
-  end
-  
-  def test_should_have_original_subject
-    assert_equal 'Hello', @message.subject
-  end
-  
-  def test_should_have_original_body
-    assert_equal 'How are you?', @message.body
-  end
-  
-  def test_should_use_receiver_as_the_sender
-    assert_equal @erich, @message.sender
-  end
-  
-  def test_should_include_to_recipients
-    assert [@erich, @john], @message.to
-  end
-  
-  def test_should_include_cc_recipients
-    assert_equal [@richard], @message.cc
-  end
-  
-  def test_should_include_bcc_recipients
-    assert_equal [@ralph], @message.bcc
-  end
-end
-
-class MessageRecipientAfterBeingDestroyedTest < ActiveSupport::TestCase
-  def setup
-    message = create_message
-    @first_recipient = create_message_recipient(
-      :message => message,
-      :receiver => create_user(:login => 'Erich'),
-      :kind => 'to'
-    )
-    @last_recipient = create_message_recipient(
-      :message => message,
-      :receiver => create_user(:login => 'Richard'),
-      :kind => 'to'
-    )
-    
-    assert @first_recipient.destroy
-    @last_recipient.reload
-  end
-  
-  def test_should_reorder_positions_of_all_other_recipients
-    assert_equal 1, @last_recipient.position
-  end
-end
-
-class MessageRecipientAsAClassTest < ActiveSupport::TestCase
-  def setup
-    message = create_message
-    @hidden_recipient = create_message_recipient(:message => message, :receiver => create_user(:login => 'erich'), :hidden_at => Time.now)
-    @visible_recipient = create_message_recipient(:message => message, :receiver => create_user(:login => 'richard'))
-  end
-  
-  def test_should_include_only_visible_messages_in_visible_scope
-    assert_equal [@visible_recipient], MessageRecipient.visible
-  end
-end