has_emails 0.0.1

data/test/unit/email_address_test.rb

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EmailAddressTest < Test::Unit::TestCase
+  fixtures :departments, :users, :email_addresses, :messages, :message_recipients, :state_changes
+  
+  def test_should_convert_email_address_using_same_model
+    e = email_addresses(:bob)
+    assert_same e, EmailAddress.convert_from(e)
+  end
+  
+  def test_should_convert_string
+    e = EmailAddress.convert_from('test@email.com')
+    assert_instance_of EmailAddress, e
+    assert_equal 'test@email.com', e.spec
+  end
+  
+  def test_should_convert_record_with_email_address_column
+    department = departments(:marketing)
+    e = EmailAddress.convert_from(department)
+    assert_instance_of EmailAddress, e
+    assert_equal 'marketing@companyxyz.com', e.spec
+  end
+  
+  def test_should_convert_record_with_email_address_association
+    user = users(:bob)
+    class << user
+      def email_address
+        EmailAddress.new(:spec => 'test@email.com')
+      end
+    end
+    
+    e = EmailAddress.convert_from(user)
+    assert_instance_of EmailAddress, e
+    assert_equal 'test@email.com', e.spec
+  end
+  
+  def test_should_convert_record_with_email_addresses_association_using_first_email_address
+    e = EmailAddress.convert_from(users(:bob))
+    assert_instance_of EmailAddress, e
+    assert_equal 'bob@bob.com', e.spec
+  end
+  
+  def test_should_raise_exception_if_converting_unknown_class_to_email_address
+    assert_raise(ArgumentError) {EmailAddress.convert_from(1)}
+  end
+  
+  def test_invalid_spec_should_not_be_valid
+    assert !EmailAddress.valid?('invalid')
+  end
+  
+  def test_valid_spec_should_be_valid
+    assert EmailAddress.valid?('valid@valid.com')
+  end
+  
+  def test_should_be_valid
+    assert_valid email_addresses(:bob)
+  end
+  
+  def test_should_require_spec
+    assert_invalid email_addresses(:bob), :spec, nil
+  end
+  
+  def test_should_require_unique_spec
+    assert_invalid email_addresses(:bob).clone, :spec
+  end
+  
+  def test_should_require_minimum_length_for_spec
+    assert_invalid email_addresses(:bob), :spec, 'ab'
+    assert_valid email_addresses(:bob), :spec, 'a@a'
+  end
+  
+  def test_should_require_maximum_length_for_spec
+    assert_invalid email_addresses(:bob), :spec, 'a' * 300 + '@' + 'a' * 20
+    assert_valid email_addresses(:bob), :spec, 'a' * 300 + '@' + 'a' * 19
+  end
+  
+  def test_should_require_specific_format_for_spec
+    assert_invalid email_addresses(:bob), :spec, 'aaaaaaaaaa'
+    assert_valid email_addresses(:bob), :spec, 'aaa@aaa.com'
+  end
+  
+  def test_should_have_polymorphic_emailable_association
+    assert_equal users(:bob), email_addresses(:bob).emailable
+  end
+  
+  def test_should_have_unsent_emails_association
+    assert_equal [messages(:unsent_from_bob)], email_addresses(:bob).unsent_emails
+  end
+  
+  def test_should_have_sent_emails_association
+    assert_equal [messages(:sent_from_bob), messages(:queued_from_bob)], email_addresses(:bob).sent_emails
+  end
+  
+  def test_should_have_received_emails_association
+    assert_equal [messages(:sent_from_bob), messages(:sent_from_mary)], email_addresses(:john).received_emails.map(&:email)
+  end
+  
+  def test_initial_state_should_be_unverified
+    assert_equal :unverified, EmailAddress.new.state.to_sym
+  end
+  
+  def test_should_verify_if_unverified
+    e = email_addresses(:bob)
+    assert e.unverified?
+    assert e.verify!
+    assert e.verified?
+  end
+  
+  def test_should_not_verify_if_verified
+    e = email_addresses(:john)
+    assert e.verified?
+    assert !e.verify!
+  end
+  
+  def test_should_create_verification_code_on_create
+    e = EmailAddress.new(:spec => 'test@me.com', :emailable => users(:bob))
+    assert_nil e.verification_code
+    assert e.save!
+    assert_not_nil e.verification_code
+    assert_equal 32, e.verification_code.length
+  end
+  
+  def test_should_not_modify_verification_code_on_update
+    e = email_addresses(:bob)
+    original_verification_code = e.verification_code
+    e.spec = 'test@me.com'
+    assert e.save!
+    assert_equal original_verification_code, e.verification_code
+  end
+  
+  def test_should_create_code_expiry_on_create
+    e = EmailAddress.new(:spec => 'test@me.com', :emailable => users(:bob))
+    assert_nil e.code_expiry
+    assert e.save!
+    assert_not_nil e.code_expiry
+  end
+  
+  def test_should_not_modify_code_expiry_on_update
+    e = email_addresses(:bob)
+    original_code_expiry = e.code_expiry
+    e.spec = 'test@me.com'
+    assert e.save!
+    assert_equal original_code_expiry, e.code_expiry
+  end
+  
+  def test_should_not_automatically_parse_local_name_after_find
+    assert_nil email_addresses(:bob).send(:instance_variable_get, '@local_name')
+  end
+  
+  def test_should_not_automatically_parse_domain_after_find
+    assert_nil email_addresses(:bob).send(:instance_variable_get, '@domain')
+  end
+  
+  def test_should_parse_local_name_when_accessed
+    assert_equal 'bob', email_addresses(:bob).local_name
+  end
+  
+  def test_should_parse_domain_when_accessed
+    assert_equal 'bob.com', email_addresses(:bob).domain
+  end
+  
+  def test_should_reset_local_name_and_domain_when_new_spec_is_set
+    e = email_addresses(:bob)
+    assert_equal 'bob', e.local_name
+    assert_equal 'bob.com', e.domain
+    
+    e.spec = 'test@me.com'
+    assert_equal 'test', e.local_name
+    assert_equal 'me.com', e.domain
+  end
+  
+  def test_name_should_be_blank_by_default
+    assert_equal '', EmailAddress.new.name
+  end
+  
+  def test_should_set_name_from_attributes
+    assert_equal 'bob', EmailAddress.new(:name => 'bob').name
+  end
+  
+  def test_should_return_spec_for_with_name_when_name_is_blank
+    e = email_addresses(:bob)
+    assert_equal e.spec, e.with_name
+  end
+  
+  def test_should_return_name_and_spec_for_with_name_when_name_is_not_blank
+    e = email_addresses(:bob)
+    e.instance_eval do
+      def name
+        'Bob'
+      end
+    end
+    
+    assert_equal 'Bob <bob@bob.com>', e.with_name
+  end
+  
+  def test_should_use_spec_for_stringification
+    e = email_addresses(:bob)
+    assert_equal e.spec, e.to_s
+  end
+end

data/test/unit/email_recipient_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EmailRecipientTest < Test::Unit::TestCase
+  fixtures :users, :email_addresses, :messages, :message_recipients, :state_changes
+  
+  def test_recipient_with_email_address_should_be_valid
+    assert_valid message_recipients(:bob_to_john)
+  end
+  
+  def test_recipient_with_receiver_spec_should_be_valid
+    assert_valid message_recipients(:bob_to_random)
+  end
+  
+  def test_recipient_with_email_address_attribute_should_be_valid
+    assert_valid message_recipients(:bob_to_marketing)
+  end
+  
+  def test_should_require_receiver_spec
+    assert_invalid message_recipients(:bob_to_random), :receiver_spec, nil
+  end
+  
+  def test_should_require_minimum_length_for_receiver_spec
+    assert_invalid message_recipients(:bob_to_random), :receiver_spec, 'ab'
+    assert_valid message_recipients(:bob_to_random), :receiver_spec, 'a@a'
+  end
+  
+  def test_should_require_maximum_length_for_receiver_spec
+    assert_invalid message_recipients(:bob_to_random), :receiver_spec, 'a' * 300 + '@' + 'a' * 20
+    assert_valid message_recipients(:bob_to_random), :receiver_spec, 'a' * 300 + '@' + 'a' * 19
+  end
+  
+  def test_should_require_specific_format_for_receiver_spec
+    assert_invalid message_recipients(:bob_to_random), :receiver_spec, 'aaaaaaaaaa'
+    assert_valid message_recipients(:bob_to_random), :receiver_spec, 'aaa@aaa.com'
+  end
+  
+  def test_email_getter_should_be_same_as_message_getter
+    r = message_recipients(:bob_to_john)
+    assert_equal r.email, r.message
+  end
+  
+  def test_email_setter_should_be_same_as_message_setter
+    r = message_recipients(:bob_to_john)
+    r.email = messages(:sent_from_mary)
+    assert_equal r.email, r.message
+  end
+  
+  def test_email_id_getter_should_be_same_as_message_id_getter
+    r = message_recipients(:bob_to_john)
+    assert_equal r.email_id, r.message_id
+  end
+  
+  def test_email_id_setter_should_be_same_as_message_id_setter
+    r = message_recipients(:bob_to_john)
+    r.email_id = messages(:sent_from_mary).id
+    assert_equal r.email_id, r.message_id
+  end
+  
+  def test_receiver_should_be_receiver_spec_if_string_recipient
+    assert_equal 'random@random.com', message_recipients(:bob_to_random).receiver
+  end
+  
+  def test_receiver_should_be_model_if_not_string_recipient
+    assert_equal email_addresses(:john), message_recipients(:bob_to_john).receiver
+  end
+  
+  def test_should_set_receiver_spec_if_receiver_is_string
+    r = EmailRecipient.new
+    r.receiver = 'test@me.com'
+    assert_equal 'test@me.com', r.receiver_spec
+  end
+  
+  def test_should_set_receiver_and_receiver_spec_if_receiver_is_not_string
+    r = EmailRecipient.new
+    r.receiver = email_addresses(:john)
+    assert_equal 'john@john.com', r.receiver_spec
+    assert_equal email_addresses(:john), r.receiver
+  end
+end

data/test/unit/email_test.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EmailTest < Test::Unit::TestCase
+  fixtures :users, :email_addresses, :messages, :message_recipients, :state_changes
+  
+  def test_should_be_valid
+    assert_valid messages(:sent_from_bob)
+  end
+  
+  def test_should_require_sender_spec
+    assert_invalid messages(:sent_from_bob), :sender_spec, nil
+  end
+  
+  def test_should_require_minimum_length_for_sender_spec
+    assert_invalid messages(:sent_from_bob), :sender_spec, 'ab'
+    assert_valid messages(:sent_from_bob), :sender_spec, 'a@a'
+  end
+  
+  def test_should_require_maximum_length_for_sender_spec
+    assert_invalid messages(:sent_from_bob), :sender_spec, 'a' * 300 + '@' + 'a' * 20
+    assert_valid messages(:sent_from_bob), :sender_spec, 'a' * 300 + '@' + 'a' * 19
+  end
+  
+  def test_should_require_specific_format_for_sender_spec
+    assert_invalid messages(:sent_from_bob), :sender_spec, 'aaaaaaaaaa'
+    assert_valid messages(:sent_from_bob), :sender_spec, 'aaa@aaa.com'
+  end
+  
+  def test_to_should_create_email_recipient
+    assert_instance_of EmailRecipient, messages(:sent_from_bob).to.build
+  end
+  
+  def test_cc_should_create_email_recipient
+    assert_instance_of EmailRecipient, messages(:sent_from_bob).cc.build
+  end
+  
+  def test_bcc_should_create_email_recipient
+    assert_instance_of EmailRecipient, messages(:sent_from_bob).bcc.build
+  end
+  
+  def test_sender_should_be_spec_if_arbitrary_email_address_used
+    assert_equal 'stranger@somewhere.com', messages(:unsent_from_stranger).sender
+  end
+  
+  def test_sender_should_be_model_if_known_email_address_used
+    assert_equal email_addresses(:bob), messages(:sent_from_bob).sender
+  end
+  
+  def test_should_set_sender_spec_if_sender_is_arbitrary_email_address
+    email = messages(:unsent_from_stranger)
+    email.sender = 'stranger@somewhereelse.com'
+    assert_equal 'stranger@somewhereelse.com', email.sender_spec
+    assert_nil email.sender_id
+    assert_nil email.sender_type
+  end
+  
+  def test_should_set_sender_and_sender_spec_if_sender_is_known_email_address
+    email = messages(:unsent_from_stranger)
+    email.sender_spec = nil
+    email.sender = email_addresses(:john)
+    assert_equal 2, email.sender_id
+    assert_equal 'EmailAddress', email.sender_type
+    assert_equal 'john@john.com', email.sender_spec
+  end
+  
+  def test_sender_email_address_should_convert_sender_spec_if_arbitrary_email_address_used
+    email_address = messages(:unsent_from_stranger).sender_email_address
+    assert_instance_of EmailAddress, email_address
+    assert_equal 'stranger@somewhere.com', email_address.spec
+  end
+  
+  def test_sender_email_address_should_use_sender_if_known_email_address_used
+    email_address = messages(:sent_from_bob).sender_email_address
+    assert_instance_of EmailAddress, email_address
+    assert_equal 'bob@bob.com', email_address.spec
+  end
+  
+  def test_reply_should_use_sender_spec_for_sender_if_arbitrary_email_address_used
+    message = messages(:unsent_from_stranger)
+    reply = message.reply
+    assert_equal 'stranger@somewhere.com', reply.sender
+  end
+  
+  def test_forward_should_use_sender_spec_for_sender_if_arbitrary_email_address_used
+    message = messages(:unsent_from_stranger)
+    forward = message.forward
+    assert_equal 'stranger@somewhere.com', forward.sender
+  end
+end

data/test/unit/has_emails_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class HasEmailsTest < Test::Unit::TestCase
+  fixtures :users, :email_addresses, :messages, :message_recipients, :state_changes
+  
+  def test_should_generate_received_association
+    assert_equal [messages(:sent_from_bob), messages(:sent_from_mary)], users(:john).received_emails.map(&:email)
+  end
+  
+  def test_should_generate_unsent_association
+    assert_equal [messages(:unsent_from_bob)], users(:bob).unsent_emails
+  end
+  
+  def test_should_generate_sent_association
+    assert_equal [messages(:sent_from_bob), messages(:queued_from_bob)], users(:bob).sent_emails
+  end
+  
+  def test_should_generate_inbox
+    assert_instance_of MessageBox, users(:bob).email_box
+  end
+  
+  def test_inbox_should_contain_received_messages
+    u = users(:bob)
+    assert_equal u.received_emails, u.email_box.inbox
+  end
+  
+  def test_inbox_should_contain_unsent_messages
+    u = users(:bob)
+    assert_equal u.unsent_emails, u.email_box.unsent
+  end
+  
+  def test_inbox_should_contain_sent_messages
+    u = users(:bob)
+    assert_equal u.sent_emails, u.email_box.sent
+  end
+end

data/test/unit/recipient_extension_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RecipientExtensionTest < Test::Unit::TestCase
+  fixtures :users, :email_addresses, :messages, :message_recipients, :state_changes
+  
+  def setup
+    @email = messages(:unsent_from_bob)
+  end
+  
+  def test_should_input_string
+    @email.to << 'test@me.com'
+    assert_equal ['john@john.com', 'test@me.com'], @email.to.map(&:email_address).map(&:to_s)
+  end
+  
+  def test_should_input_receiver
+    @email.to << email_addresses(:bob)
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_input_message_recipients
+    @email.to << EmailRecipient.new(:receiver => email_addresses(:bob), :kind => 'to')
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_push_string
+    @email.to.push('test@me.com')
+    assert_equal ['john@john.com', 'test@me.com'], @email.to.map(&:email_address).map(&:to_s)
+  end
+  
+  def test_should_push_receiver
+    @email.to.push(email_addresses(:bob))
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_push_message_recipients
+    @email.to.push(EmailRecipient.new(:receiver => email_addresses(:bob), :kind => 'to'))
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_concat_string
+    @email.to.concat(['test@me.com'])
+    assert_equal ['john@john.com', 'test@me.com'], @email.to.map(&:email_address).map(&:to_s)
+  end
+  
+  def test_should_concat_receiver
+    @email.to.concat([email_addresses(:bob)])
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_concat_message_recipients
+    @email.to.concat([EmailRecipient.new(:receiver => email_addresses(:bob), :kind => 'to')])
+    assert_equal [email_addresses(:john), email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_delete_string
+    @email.to.delete('john@john.com')
+    assert_equal [], @email.to_receivers
+  end
+  
+  def test_should_delete_receiver
+    @email.to.delete(email_addresses(:john))
+    assert_equal [], @email.to_receivers
+  end
+  
+  def test_should_delete_message_recipients
+    @email.to.delete(@email.to.first)
+    assert_equal [], @email.to
+  end
+  
+  def test_should_replace_string
+    @email.to.replace(['bob@bob.com'])
+    assert_equal ['bob@bob.com'], @email.to.map(&:email_address).map(&:to_s)
+  end
+  
+  def test_should_replace_receiver
+    @email.to.replace([email_addresses(:bob)])
+    assert_equal [email_addresses(:bob)], @email.to_receivers
+  end
+  
+  def test_should_replace_message_recipients
+    @email.to.replace([])
+    assert_equal [], @email.to_receivers
+  end
+  
+  def test_should_set_kind_for_to_recipients
+    @email.to << users(:bob)
+    assert_equal 'to', @email.to.last.kind
+  end
+  
+  def test_should_set_kind_for_cc_recipients
+    @email.cc << users(:bob)
+    assert_equal 'cc', @email.cc.last.kind
+  end
+  
+  def test_should_set_kind_for_bcc_recipients
+    @email.bcc << users(:bob)
+    assert_equal 'bcc', @email.bcc.last.kind
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: has_emails
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-09-26 00:00:00 -04:00
+summary: Adds support for emailing capabilities between ActiveRecord models.
+require_paths: 
+- lib
+email: info@pluginaweek.org
+homepage: http://www.pluginaweek.org
+rubyforge_project: 
+description: 
+autorequire: has_emails
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Aaron Pfeifer, Neil Abraham
+files: 
+- app/mailers
+- app/models
+- app/mailers/application_mailer.rb
+- app/models/email_recipient.rb
+- app/models/email_recipient_build_extension.rb
+- app/models/email_address.rb
+- app/models/email.rb
+- db/bootstrap
+- db/migrate
+- db/bootstrap/events.yml
+- db/bootstrap/states.yml
+- db/migrate/001_create_email_addresses.rb
+- db/migrate/003_add_email_recipient_specs.rb
+- db/migrate/002_add_email_specs.rb
+- lib/has_emails.rb
+- test/test_helper.rb
+- test/fixtures
+- test/app_root
+- test/unit
+- test/fixtures/users.yml
+- test/fixtures/message_recipients.yml
+- test/fixtures/state_changes.yml
+- test/fixtures/messages.yml
+- test/fixtures/departments.yml
+- test/fixtures/email_addresses.yml
+- test/app_root/config
+- test/app_root/app
+- test/app_root/db
+- test/app_root/config/environment.rb
+- test/app_root/app/models
+- test/app_root/app/models/user.rb
+- test/app_root/app/models/department.rb
+- test/app_root/db/migrate
+- test/app_root/db/migrate/002_create_departments.rb
+- test/app_root/db/migrate/001_create_users.rb
+- test/unit/email_test.rb
+- test/unit/email_address_test.rb
+- test/unit/has_emails_test.rb
+- test/unit/email_recipient_test.rb
+- test/unit/recipient_extension_test.rb
+- test/unit/application_mailer_test.rb
+- CHANGELOG
+- init.rb
+- MIT-LICENSE
+- Rakefile
+- README
+test_files: 
+- test/unit/email_test.rb
+- test/unit/email_address_test.rb
+- test/unit/has_emails_test.rb
+- test/unit/email_recipient_test.rb
+- test/unit/recipient_extension_test.rb
+- test/unit/application_mailer_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: has_messages
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: validates_as_email_address
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: