has_emails 0.0.1 → 0.1.0

data/test/unit/email_address_test.rb

@@ -1,200 +1,148 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(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
+class EmailAddressByDefaultTest < Test::Unit::TestCase
+  def setup
+    @email_address = EmailAddress.new
   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
+  def test_should_not_have_a_name
+    assert @email_address.name.blank?
   end
   
-  def test_should_raise_exception_if_converting_unknown_class_to_email_address
-    assert_raise(ArgumentError) {EmailAddress.convert_from(1)}
+  def test_should_not_have_a_spec
+    assert @email_address.name.blank?
   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
+
+class EmailAddressTest < Test::Unit::TestCase
+  def test_should_be_valid_with_a_set_of_valid_attributes
+    email_address = new_email_address
+    assert email_address.valid?
   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'
+  def test_should_require_a_spec
+    email_address = new_email_address(:spec => nil)
+    assert !email_address.valid?
+    assert_equal 3, Array(email_address.errors.on(:spec)).size
   end
   
-  def test_should_have_polymorphic_emailable_association
-    assert_equal users(:bob), email_addresses(:bob).emailable
+  def test_should_require_a_properly_formatted_email
+    email_address = new_email_address(:spec => '!@@!@@!')
+    assert !email_address.valid?
+    assert_equal 1, Array(email_address.errors.on(:spec)).size
   end
   
-  def test_should_have_unsent_emails_association
-    assert_equal [messages(:unsent_from_bob)], email_addresses(:bob).unsent_emails
+  def test_should_not_allow_emails_less_than_3_characters
+    email_address = new_email_address(:spec => 'aa')
+    assert !email_address.valid?
+    assert_equal 2, Array(email_address.errors.on(:spec)).size
+    
+    email_address.spec = 'a@a'
+    assert email_address.valid?
   end
   
-  def test_should_have_sent_emails_association
-    assert_equal [messages(:sent_from_bob), messages(:queued_from_bob)], email_addresses(:bob).sent_emails
+  def test_should_not_allow_emails_longer_than_320_characters
+    email_address = new_email_address(:spec => 'a' * 314 + '@a.com')
+    assert email_address.valid?
+    
+    email_address.spec += 'a'
+    assert !email_address.valid?
+    assert_equal 1, Array(email_address.errors.on(:spec)).size
   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)
+  def test_should_require_a_unique_spec_scoped_by_name
+    email_address = create_email_address(:spec => 'john.smith@gmail.com', :name => 'John Smith')
+    
+    second_email_address = new_email_address(:spec => 'john.smith@gmail.com', :name => 'John Smith II')
+    assert second_email_address.valid?
+    
+    second_email_address = new_email_address(:spec => 'john.smith@gmail.com', :name => 'John Smith')
+    assert !second_email_address.valid?
+    assert_equal 1, Array(second_email_address.errors.on(:spec)).size
   end
   
-  def test_initial_state_should_be_unverified
-    assert_equal :unverified, EmailAddress.new.state.to_sym
+  def test_should_not_require_a_name
+    email_address = new_email_address(:name => nil)
+    assert email_address.valid?
   end
-  
-  def test_should_verify_if_unverified
-    e = email_addresses(:bob)
-    assert e.unverified?
-    assert e.verify!
-    assert e.verified?
+end
+
+class EmailAddressFromAddressTest < Test::Unit::TestCase
+  def setup
+    @email_address = EmailAddress.new(:address => 'John Smith <john.smith@gmail.com>')
   end
   
-  def test_should_not_verify_if_verified
-    e = email_addresses(:john)
-    assert e.verified?
-    assert !e.verify!
+  def test_should_be_valid
+    assert @email_address.valid?
   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
+  def test_should_find_a_name
+    assert_equal 'John Smith', @email_address.name
   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
+  def test_should_find_a_spec
+    assert_equal 'john.smith@gmail.com', @email_address.spec
   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
+
+class EmailAddressFromAddressWithoutNameTest < Test::Unit::TestCase
+  def setup
+    @email_address = EmailAddress.new(:address => 'john.smith@gmail.com')
   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
+  def test_should_be_valid
+    assert @email_address.valid?
   end
   
-  def test_should_not_automatically_parse_local_name_after_find
-    assert_nil email_addresses(:bob).send(:instance_variable_get, '@local_name')
+  def test_should_not_find_a_name
+    assert @email_address.name.blank?
   end
   
-  def test_should_not_automatically_parse_domain_after_find
-    assert_nil email_addresses(:bob).send(:instance_variable_get, '@domain')
+  def test_should_find_a_spec
+    assert_equal 'john.smith@gmail.com', @email_address.spec
   end
-  
-  def test_should_parse_local_name_when_accessed
-    assert_equal 'bob', email_addresses(:bob).local_name
+end
+
+class EmailAddressAfterBeingCreatedTest < Test::Unit::TestCase
+  def setup
+    @email_address = create_email_address(:name => 'John Smith', :spec => 'john.smith@gmail.com')
   end
   
-  def test_should_parse_domain_when_accessed
-    assert_equal 'bob.com', email_addresses(:bob).domain
+  def test_should_record_when_it_was_created
+    assert_not_nil @email_address.created_at
   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
+  def test_should_record_when_it_was_updated
+    assert_not_nil @email_address.updated_at
   end
   
-  def test_name_should_be_blank_by_default
-    assert_equal '', EmailAddress.new.name
+  def test_should_generate_an_address_with_the_name
+    assert_equal 'John Smith <john.smith@gmail.com>', @email_address.with_name
   end
-  
-  def test_should_set_name_from_attributes
-    assert_equal 'bob', EmailAddress.new(:name => 'bob').name
+end
+
+class EmailAddressAsAClassTest < Test::Unit::TestCase
+  def test_should_be_able_to_split_address_containing_name
+    name, spec = EmailAddress.split_address('John Smith <john.smith@gmail.com>')
+    assert_equal 'John Smith', name
+    assert_equal 'john.smith@gmail.com', spec
   end
   
-  def test_should_return_spec_for_with_name_when_name_is_blank
-    e = email_addresses(:bob)
-    assert_equal e.spec, e.with_name
+  def test_should_be_able_to_split_address_not_containing_name
+    name, spec = EmailAddress.split_address('john.smith@gmail.com')
+    assert_nil name
+    assert_equal 'john.smith@gmail.com', spec
   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
+  def test_should_be_able_to_find_an_existing_email_by_address
+    email_address = create_email_address(:address => 'John Smith <john.smith@gmail.com>')
+    assert_equal email_address, EmailAddress.find_or_create_by_address('John Smith <john.smith@gmail.com>')
   end
   
-  def test_should_use_spec_for_stringification
-    e = email_addresses(:bob)
-    assert_equal e.spec, e.to_s
+  def test_should_be_able_to_create_from_a_new_address
+    email_address = EmailAddress.find_or_create_by_address('John Smith <john.smith@gmail.com>')
+    assert !email_address.new_record?
+    assert_equal 'John Smith', email_address.name
+    assert_equal 'john.smith@gmail.com', email_address.spec
   end
 end

data/test/unit/email_test.rb

@@ -1,89 +1,29 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(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
+class EmailAfterBeingDeliveredTest < Test::Unit::TestCase
+  def setup
+    ActionMailer::Base.deliveries = []
+    
+    @email = new_email(
+      :subject => 'Hello',
+      :body => 'How are you?',
+      :sender => create_email_address(:spec => 'webmaster@localhost'),
+      :to => create_email_address(:spec => 'partners@localhost'),
+      :cc => create_email_address(:spec => 'support@localhost'),
+      :bcc => create_email_address(:spec => 'feedback@localhost')
+    )
+    assert @email.deliver!
+  end
+  
+  def test_should_send_mail
+    assert ActionMailer::Base.deliveries.any?
+    
+    delivery = ActionMailer::Base.deliveries.first
+    assert_equal 'Hello', delivery.subject
+    assert_equal 'How are you?', delivery.body
+    assert_equal ['webmaster@localhost'], delivery.from
+    assert_equal ['partners@localhost'], delivery.to
+    assert_equal ['support@localhost'], delivery.cc
+    assert_equal ['feedback@localhost'], delivery.bcc
   end
 end

metadata

@@ -1,113 +1,104 @@
 --- !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: 
+  version: 0.1.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
-- Aaron Pfeifer, Neil Abraham
+- Aaron Pfeifer
+autorequire: has_emails
+bindir: bin
+cert_chain: []
+
+date: 2008-05-05 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: has_messages
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: validates_as_email_address
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.2
+    version: 
+description: 
+email: aaron@pluginaweek.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 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
+- lib/has_emails
+- lib/has_emails/extensions
+- lib/has_emails/extensions/action_mailer.rb
+- test/factory.rb
 - 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/db/migrate
+- test/app_root/db/migrate/002_migrate_has_emails_to_version_1.rb
+- test/app_root/db/migrate/001_migrate_has_messages_to_version_2.rb
+- test/app_root/config
 - test/app_root/config/environment.rb
+- test/app_root/app
 - 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/app_root/app/models/empty
+- test/functional
+- test/functional/has_emails_test.rb
+- test/test_helper.rb
+- test/unit
 - 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
+- test/unit/action_mailer_test.rb
+- test/unit/email_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
+has_rdoc: true
+homepage: http://www.pluginaweek.org
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 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: 
+rubyforge_project: 
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: Demonstrates a reference implementation for sending emails with logging and asynchronous support.
+test_files: 
+- test/functional/has_emails_test.rb
+- test/unit/email_address_test.rb
+- test/unit/action_mailer_test.rb
+- test/unit/email_test.rb