email_veracity 0.4.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.tmproj
+.DS_Store
+/coverage
+/pkg
+/rdoc

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Carsten Nielsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+Email Veracity
+==============
+
+A straight-forward Ruby library for checking the real-world validity of email
+addresses.
+
+
+### It Can
+
+ * Validate email addresses for proper form against a pattern.
+ * Accept and reject addresses based whitelists and blacklists of domains.
+ * Check an address' domain for MX and/or A records.
+ * Be configured for a variety of use-cases, to be as discerning or as
+   indiscriminate as you would like.
+
+
+### It Can Not
+
+ * Validate all possible permutations of addresses to the RFC 2822
+   specification.
+
+
+A Note About The ActiveRecord Plugin
+------------------------------------
+
+**It's dead!** Why? Determining the validity of an email address based on a lookup of its domain is a good idea, but basing it off of one single test done inline with a request is not. A name server might be down, shit happens, and you might be snubbing a totally legitimate person from using your product — not good.
+
+I feel a better solution is to check the pattern of the email address and perhaps check it against the blacklist on creation. The other tests should be done in the background over the period of many days and be added to a log. A report can then be performed and you can statistically determine the addresses that are most likely false and take appropriate action from that point. 
+
+
+Using The Gem
+-------------
+
+In your project, you must require `email_veracity` after that you can try it
+out, consider the following examples:
+
+    
+    require 'email_veracity'
+    
+    address = EmailVeracity::Address.new('heycarsten@gmail.com')
+    
+    address.valid?
+    # => true
+    
+    address.domain.to_s
+    # => 'gmail.com'
+    
+    address.domain.address_servers.map { |s| s.to_s }
+    # => ["64.233.171.83", "64.233.161.83", "209.85.171.83"]
+    
+    address = EmailVeracity::Address.new('fakey@crazy-z3d9df-domain.com')
+    
+    address.valid?
+    # => false
+    
+    address.errors
+    # => [:no_address_servers]
+    
+
+As you can see, playing with the core library is pretty fun.  The basic building
+blocks are:
+
+#### Address
+
+Responsible for parsing full email addresses and checking for pattern-based
+validity.
+
+#### Domain
+
+Contains methods to query the domain for information.
+
+#### Resolver
+
+Abstracts Resolv::DNS into a super-simple single public method, this is where
+the timeout error is raised.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'email_veracity'
+    gem.summary = 'A simple library for checking the real-world validity of email addresses.'
+    gem.description = 'Email Veracity abstracts an email address into a series of objects which makes it easy to see if an address is invalid, and if so, why.'
+    gem.email = 'heycarsten@gmail.com'
+    gem.homepage = 'http://github.com/heycarsten/email-veracity'
+    gem.authors = 'Carsten Nielsen'
+    gem.add_development_dependency 'mocha', '>= 0.9.8'
+    gem.add_development_dependency 'shoulda', '>= 2.10.2'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "email-veracity #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/email_veracity.gemspec

@@ -0,0 +1,75 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{email_veracity}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Carsten Nielsen"]
+  s.date = %q{2009-12-12}
+  s.description = %q{Email Veracity abstracts an email address into a series of objects which makes it easy to see if an address is invalid, and if so, why.}
+  s.email = %q{heycarsten@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "email_veracity.gemspec",
+     "lib/email_veracity.rb",
+     "lib/email_veracity/address.rb",
+     "lib/email_veracity/config.rb",
+     "lib/email_veracity/domain.rb",
+     "lib/email_veracity/resolver.rb",
+     "lib/email_veracity/server.rb",
+     "lib/email_veracity/utils.rb",
+     "lib/email_veracity/validatability.rb",
+     "test/helper.rb",
+     "test/test_address.rb",
+     "test/test_config.rb",
+     "test/test_domain.rb",
+     "test/test_resolver.rb",
+     "test/test_server.rb",
+     "test/test_utils.rb",
+     "test/test_validatability.rb"
+  ]
+  s.homepage = %q{http://github.com/heycarsten/email-veracity}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A simple library for checking the real-world validity of email addresses.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_address.rb",
+     "test/test_config.rb",
+     "test/test_domain.rb",
+     "test/test_resolver.rb",
+     "test/test_server.rb",
+     "test/test_utils.rb",
+     "test/test_validatability.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_development_dependency(%q<shoulda>, [">= 2.10.2"])
+    else
+      s.add_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_dependency(%q<shoulda>, [">= 2.10.2"])
+    end
+  else
+    s.add_dependency(%q<mocha>, [">= 0.9.8"])
+    s.add_dependency(%q<shoulda>, [">= 2.10.2"])
+  end
+end
+

data/lib/email_veracity/address.rb

@@ -0,0 +1,37 @@
+module EmailVeracity
+  class Address
+
+    include Validatability
+
+    attr_reader :domain
+
+    def initialize(email = '')
+      self.email_address = email
+    end
+
+    def to_s
+      email_address
+    end
+
+    def email_address
+      @email_address.to_s.strip
+    end
+
+    def email_address=(new_email_address)
+      @email_address = new_email_address.to_s
+      @domain = Domain.new(@email_address.split('@')[1] || '')
+    end
+
+    protected
+
+    def validate!
+      add_error(:malformed) if !pattern_valid?
+      add_errors(domain.errors)
+    end
+
+    def pattern_valid?
+      @email_address =~ Config[:valid_pattern]
+    end
+
+  end
+end

data/lib/email_veracity/config.rb

@@ -0,0 +1,71 @@
+module EmailVeracity
+  module Config
+
+    DEFAULT_OPTIONS = {
+      :whitelist => %w[ aol.com gmail.com hotmail.com mac.com msn.com
+        rogers.com sympatico.ca yahoo.com telus.com sprint.com sprint.ca ],
+      :blacklist => %w[ dodgeit.com mintemail.com mintemail.uni.cc
+        1mintemail.mooo.com spammotel.com trashmail.net ],
+      :valid_pattern => %r{\A
+        (
+          (
+            [a-z0-1]{1}
+            |
+            [\w]+[\w\+_\-\.]+
+            [\+_\-\.]{0}
+          )
+          @
+          (
+            (?:
+              [-a-z0-9]+\.
+            )+
+            [a-z]{2,}
+          )
+        ){1}
+      \Z}xi,
+      :must_include => [], # :a, :mx
+      :timeout => 2,
+      :enforce_blacklist => false,
+      :enforce_whitelist => true }
+    @options = DEFAULT_OPTIONS.clone
+
+    def [](key)
+      @options[key.to_sym]
+    end
+
+    def []=(key, value)
+      @options[key.to_sym] = value
+    end
+
+    def options
+      @options
+    end
+
+    def options=(options)
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options must be a Hash not #{options.class}"
+      end
+      @options = options
+    end
+
+    def update(options)
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options must be a Hash not #{options.class}"
+      end
+      @options.update(options)
+    end
+
+    def enforced_record?(record)
+      return unless @options[:must_include].is_a?(Array)
+      @options[:must_include].any? { |i| i.to_s == record.to_s }
+    end
+
+    def revert!
+      @options = DEFAULT_OPTIONS.clone
+    end
+
+    module_function :[], :[]=, :options, :options=, :update, :enforced_record?,
+      :revert!
+
+  end
+end

data/lib/email_veracity/domain.rb

@@ -0,0 +1,69 @@
+module EmailVeracity
+  class Domain
+
+    include Validatability
+
+    def self.whitelisted?(name)
+      Config[:whitelist].include?(name.downcase.strip)
+    end
+
+    def self.blacklisted?(name)
+      Config[:blacklist].include?(name.downcase.strip)
+    end
+
+    def initialize(name = '')
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    def name
+      @name.to_s.downcase.strip
+    end
+
+    def whitelisted?
+      Domain.whitelisted?(name)
+    end
+
+    def blacklisted?
+      Domain.blacklisted?(name)
+    end
+
+    def address_servers
+      @address_servers ||= servers_in(:a)
+    end
+
+    def exchange_servers
+      @exchange_servers ||= servers_in(:mx)
+    end
+
+    def servers
+      address_servers + exchange_servers
+    end
+
+    protected
+
+    def validate!
+      return if whitelisted?
+      add_error(:blacklisted) if blacklisted? &&
+        Config[:enforce_blacklist]
+      add_error(:no_records) if servers.empty? &&
+        !Config.enforced_record?(:a) &&
+        !Config.enforced_record?(:mx)
+      add_error(:no_address_servers) if address_servers.empty? &&
+        Config.enforced_record?(:a)
+      add_error(:no_exchange_servers) if exchange_servers.empty? &&
+        Config.enforced_record?(:mx)
+    end
+
+    def servers_in(record)
+      return [] if Utils.blank?(name)
+      Resolver.get_servers_for(name, record)
+     rescue DomainResourcesTimeoutError
+      add_error :timed_out
+    end
+
+  end
+end

data/lib/email_veracity/resolver.rb

@@ -0,0 +1,45 @@
+module EmailVeracity
+  module Resolver
+
+    RECORD_NAMES_TO_RESOLVE_MAP = {
+      :a => {
+        :method => 'address',
+        :type => AddressServer,
+        :constant => Resolv::DNS::Resource::IN::A },
+      :mx => {
+        :method => 'exchange',
+        :type => ExchangeServer,
+        :constant => Resolv::DNS::Resource::IN::MX } }
+
+    def get_servers_for(domain_name, record = :a)
+      Timeout::timeout(Config[:timeout]) do
+        get_resources_for(domain_name, record).map do |server_name|
+          type = RECORD_NAMES_TO_RESOLVE_MAP[record.to_sym][:type]
+          type.new(server_name)
+        end
+      end
+     rescue Timeout::Error
+      raise DomainResourcesTimeoutError,
+        "Timed out while try to resolve #{domain_name}"
+    end
+
+    protected
+
+    def get_resources_for(domain_name, record = :a)
+      Resolv::DNS.open do |server|
+        record_map = RECORD_NAMES_TO_RESOLVE_MAP[record]
+        resources = server.getresources(domain_name, record_map[:constant])
+        resources_to_servers(resources, record_map[:method])
+      end
+    end
+
+    def resources_to_servers(resources, resolve_method)
+      resources.inject([]) do |array, resource|
+        array << resource.method(resolve_method).call.to_s.strip
+      end.reject { |i| Utils.blank?(i) }
+    end
+
+    module_function :get_servers_for, :get_resources_for, :resources_to_servers
+
+  end
+end

data/lib/email_veracity/server.rb

@@ -0,0 +1,18 @@
+module EmailVeracity
+
+  class Server
+
+    attr_reader :name
+    alias_method :to_s, :name
+
+    def initialize(name = '')
+      @name = name
+    end
+
+  end
+
+
+  class AddressServer < Server; end
+  class ExchangeServer < Server; end
+
+end

data/lib/email_veracity/utils.rb

@@ -0,0 +1,11 @@
+module EmailVeracity
+  module Utils
+
+    def blank?(obj)
+      obj.respond_to?(:empty?) ? obj.empty? : !obj
+    end
+
+    module_function :blank?
+
+  end
+end

data/lib/email_veracity/validatability.rb

@@ -0,0 +1,31 @@
+module EmailVeracity
+  module Validatability
+
+    def valid?
+      self.errors.empty?
+    end
+
+    def errors
+      self.clear_errors!
+      self.validate!
+      @errors
+    end
+
+    protected
+
+    def validate!
+      # Adds errors to the object.
+    end
+
+    def clear_errors!
+      @errors = []
+    end
+
+    def add_error(*new_errors)
+      @errors ||= []
+      @errors.concat(new_errors.flatten)
+    end
+    alias_method :add_errors, :add_error
+
+  end
+end

data/lib/email_veracity.rb

@@ -0,0 +1,19 @@
+require 'resolv'
+require 'timeout'
+
+require 'email_veracity/utils'
+require 'email_veracity/validatability'
+require 'email_veracity/config'
+require 'email_veracity/server'
+require 'email_veracity/resolver'
+require 'email_veracity/domain'
+require 'email_veracity/address'
+
+
+module EmailVeracity
+
+  class Error < StandardError; end
+  class MalformedEmailAddressError < Error; end
+  class DomainResourcesTimeoutError < Error; end
+
+end

data/test/helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'redgreen'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'email_veracity'
+
+
+class ClassWithValidationMock
+
+  include EmailVeracity::Validatability
+
+  attr_accessor :give_error
+  attr_accessor :give_errors
+  attr_accessor :give_array_of_errors
+
+  def validate!
+    add_error(:one) if give_error
+    add_errors(:two, :three) if give_errors
+    add_errors([:four, :five]) if give_array_of_errors
+    add_errors []
+  end
+
+end
+
+
+class Test::Unit::TestCase
+
+  def assert_empty(array, message = nil)
+    unless array.is_a?(Array)
+      raise ArgumentError, 'First argument must be an Array'
+    end
+    message = [message, "Expected #{array.inspect} to be empty."].
+      flatten.join("\n")
+    assert_block(message) { array.empty? }
+  end
+
+  def assert_not_empty(array, message = nil)
+    unless array.is_a?(Array)
+      raise ArgumentError, 'First argument must be an Array'
+    end
+    message = [message, "Expected #{array.inspect} to contain items."].
+      flatten.join("\n")
+    assert_block(message) { !array.empty? }
+  end
+
+end

data/test/test_address.rb

@@ -0,0 +1,54 @@
+require 'helper'
+
+
+class TestAddress < Test::Unit::TestCase
+
+  def test_initialize
+    assert_instance_of EmailVeracity::Address,
+      EmailVeracity::Address.new('heycarsten@gmail.com'),
+      'Should create a new Address object.'
+    assert_instance_of Array,
+      EmailVeracity::Address.new('heycarsten@gmail.com').errors,
+      '#errors should be an array.'
+  end
+
+end
+
+
+class DefaultConfigurationAddressValidationsTest < Test::Unit::TestCase
+
+  def test_a_nil_address_argument
+    address = new_address(nil)
+    assert !address.valid?, 'Should be invalid.'
+  end
+
+  def test_a_well_formed_address_with_a_whitelisted_domain
+    address = new_address('heycarsten@gmail.com')
+    assert address.valid?, "Should be valid. @errors: #{address.errors.inspect}"
+  end
+
+  def test_a_well_formed_address_with_a_blacklisted_domain
+    address = new_address('heycarsten@dodgeit.com')
+    address.stubs(:domain).returns(stub(:errors => [:blacklisted]))
+    assert !address.valid?, "Should not be valid. @errors: #{address.errors.inspect}"
+  end
+
+  def test_a_well_formed_address_that_does_not_exist
+    address = new_address('heycarsten@i-surely-do-not-exist.nil')
+    address.stubs(:domain).returns(stub(:errors => [:no_records]))
+    assert !address.valid?, 'Should not be valid.'
+  end
+
+  def test_a_well_formed_address_that_exists
+    address = new_address('itsme@heycarsten.com')
+    address.stubs(:domain).returns(stub(:errors => []))
+    assert address.valid?, "Should be valid. @errors: #{address.errors.inspect}"
+  end
+
+  private
+
+  def new_address(address = '')
+    EmailVeracity::Address.new(address)
+  end
+
+end

data/test/test_config.rb

@@ -0,0 +1,101 @@
+require 'helper'
+
+class TestConfig < Test::Unit::TestCase
+
+  VALID_EMAIL_ADDRESS_EXAMPLES = %w[
+    goto@rubyfringe.ca
+    went.to@futureruby.com
+    heyd00d+stuff@gmail.com
+    carsten_nielsen@gmail.com
+    carsten-nielsen@gmail.com
+    goodoldemail@address.ca
+    old-skool@mail.mysite.on.ca
+    heycarsten@del.icio.us
+    nex3@haml.town
+    1234@aplace.com
+    carsten2@happyland.net
+    sweetCandy4@me-and-you.ca
+    simple@example.com
+    neat@b.eat
+    i@shouldwork.com
+    1@shouldworktoo.com ]
+  INVALID_EMAIL_ADDRESS_EXAMPLES = %w[
+    @failure.net
+    craptastic@
+    !!!!!@gmail.com
+    oh-noez@f4iL/\/\@il.net
+    someone@somewhere
+    this!fails@comtown.com
+    $oWrong@fail.net
+    charles\ babbage@gmail.com
+    ,@crap.com
+    dis%20blos@dot.com
+    &^%$#$%@yojimbo.nil
+    "greetings\ friend"@comtastic.dk
+    this,fails@ice-t.com
+    ungültige@adresse.de
+    failure@10.0.0.1
+    douche@@bag.net
+    .@fail.net
+    -@fail.org
+    _@fail.org
+    +_-@fail.die
+    +___--@crashburn.net ]
+
+  context 'Default email pattern' do
+    should 'match valid addresses' do
+      VALID_EMAIL_ADDRESS_EXAMPLES.each do |example|
+        assert_match EmailVeracity::Config[:valid_pattern], example
+      end
+    end
+
+    should 'not match invalid addresses' do
+      INVALID_EMAIL_ADDRESS_EXAMPLES.each do |example|
+        assert_no_match EmailVeracity::Config[:valid_pattern], example
+      end
+    end
+  end
+
+  def test_default_whitelist_domains
+    assert_instance_of Array, EmailVeracity::Config[:whitelist]
+    assert_not_empty EmailVeracity::Config[:whitelist],
+      'Should have more than one item.'
+  end
+
+  def test_default_blacklist_domains
+    assert_instance_of Array, EmailVeracity::Config[:blacklist]
+    assert_not_empty EmailVeracity::Config[:blacklist],
+      'Should have more than one item.'
+  end
+
+  def test_must_include_default_setting
+    assert_instance_of Array, EmailVeracity::Config[:must_include]
+  end
+
+  def test_enforced_record_with_symbols
+    assert !EmailVeracity::Config.enforced_record?(:a),
+      'Should not check for A records by default'
+    assert !EmailVeracity::Config.enforced_record?(:mx),
+      'Should not check for MX records be default'
+  end
+
+  def test_enforce_lookup_with_strings
+    assert !EmailVeracity::Config.enforced_record?('a'),
+      'Should not check for A records by default'
+    assert !EmailVeracity::Config.enforced_record?('mx'),
+      'Should not check for MX records be default'
+  end
+
+  def test_changing_and_reverting_configuration
+    EmailVeracity::Config.update(:lookup => false, :timeout => 3)
+    assert_equal false, EmailVeracity::Config[:lookup],
+      'Should change configuration.'
+    assert_equal 3, EmailVeracity::Config[:timeout]
+      'Should change configuration.'
+    EmailVeracity::Config.revert!
+    assert_equal EmailVeracity::Config::DEFAULT_OPTIONS,
+      EmailVeracity::Config.options,
+      'Should revert configuration'
+  end
+
+end

data/test/test_domain.rb

@@ -0,0 +1,94 @@
+require 'helper'
+
+class TestDomain < Test::Unit::TestCase
+
+  def test_blacklisted_domain
+    assert EmailVeracity::Domain.blacklisted?('dodgeit.com'),
+      'Should match a blacklisted domain.'
+    assert EmailVeracity::Domain.blacklisted?('DoDgEiT.cOm'),
+      'Should match a blacklisted domain regardless of case.'
+    assert EmailVeracity::Domain.blacklisted?(" dodgeit.com  \r\n "),
+      'Should match a blacklisted domain regardless of whitespace.'
+    assert !EmailVeracity::Domain.blacklisted?('iamnotblacklisted.com'),
+      'Should not match a non-blacklisted domain.'
+  end
+
+  def test_whitelisted_domain
+    assert EmailVeracity::Domain.whitelisted?('gmail.com'),
+      'Should match a whitelisted domain.'
+    assert EmailVeracity::Domain.whitelisted?('GmAiL.cOm'),
+      'Should match a whitelisted domain regardless of case.'
+    assert EmailVeracity::Domain.whitelisted?(" gmail.com  \r\n "),
+      'Should match a whitelisted domain regardless of whitespace.'
+    assert !EmailVeracity::Domain.whitelisted?('iamnotwhitelisted.com'),
+      'Should not match a non-whitelisted domain.'
+  end
+
+  def test_initializing_a_new_domain_with_whitespace
+    domain = new_domain('  heycarsten.com  ')
+    assert_equal 'heycarsten.com', domain.name, 'Should strip whitespace.'
+    assert_respond_to domain, :to_s, 'Should have a to_s method.'
+  end
+
+  def test_a_valid_domain_for_address_servers
+    domain_name = 'gmail.com'
+    domain = new_domain(domain_name)
+    EmailVeracity::Resolver.expects(:get_servers_for).
+      with(domain_name, :a).returns(["mail.#{domain_name}"])
+    assert_not_empty domain.address_servers, 'Should contain address servers.'
+  end
+
+  def test_a_valid_domain_for_exchange_servers
+    domain_name = 'gmail.com'
+    domain = new_domain(domain_name)
+    EmailVeracity::Resolver.expects(:get_servers_for).
+      with(domain_name, :mx).returns(["mail.#{domain_name}"])
+    assert_not_empty domain.exchange_servers, 'Should contain mail servers.'
+  end
+
+  def test_an_invalid_domain_for_address_servers
+    domain = new_domain('i-surely-do-not.exist')
+    domain.expects(:servers_in).with(:a).returns([])
+    assert_empty domain.address_servers, 'Should not contain address servers.'
+  end
+  
+  def test_an_invalid_domain_for_exchange_servers
+    domain = new_domain('i-surely-do-not.exist')
+    domain.expects(:servers_in).with(:mx).returns([])
+    assert_empty domain.exchange_servers, 'Should not contain exchange servers.'
+  end
+
+  def test_a_blank_domain_for_servers
+    domain = new_domain('')
+    assert_empty domain.exchange_servers, 'Should not contain exchange servers.'
+    assert_empty domain.address_servers, 'Should not contain address servers.'
+  end
+
+  def test_for_errors_on_a_valid_domain
+    domain = new_domain('yahoo.com')
+    assert_empty domain.errors, 'Should not have errors.'
+  end
+
+  context 'A domain with no address records or exchange records' do
+    setup do
+      @domain = new_domain('nothingtoseehere.org')
+      @domain.stubs(:address_servers).returns([])
+      @domain.stubs(:exchange_servers).returns([])
+    end
+
+    should 'not pass validation' do
+      assert !@domain.valid?
+    end
+
+    should 'indicate the appropriate error' do
+      assert @domain.errors.include?(:no_records)
+    end
+  end
+
+  private
+
+  def new_domain(name = 'heycarsten.com')
+    EmailVeracity::Domain.new(name)
+  end
+
+end

data/test/test_resolver.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestResolver < Test::Unit::TestCase
+
+  DOMAIN_NAMES = %w[
+    viarails.net heycarsten.com yahoo.com gmail.com savvica.com
+    okayfail.com github.com google.com rogers.com amd.com adobe.com
+    unspace.ca xerox.com webkit.org cooltown.net aiderss.com delicious.com ]
+
+  def test_consecutive_queries
+    DOMAIN_NAMES.each do |domain_name|
+      EmailVeracity::Resolver.stubs(:get_resources_for).
+        with(domain_name, kind_of(Symbol)).returns(["mail.#{domain_name}"])
+    end
+    assert_nothing_raised do
+      DOMAIN_NAMES.each do |domain|
+        assert_instance_of Array, EmailVeracity::Resolver.get_servers_for(domain),
+          'Should return an array of servers'
+      end
+    end
+  end
+
+  def test_timing_out_while_resolving_a_domain
+    domain = 'okayfail.com'
+    timeout_exception = Timeout::Error.new('The connection has timed out')
+    EmailVeracity::Resolver.stubs(:get_resources_for).
+      with(domain, kind_of(Symbol)).raises(timeout_exception)
+    assert_raise EmailVeracity::DomainResourcesTimeoutError, 'Should time out' do
+      EmailVeracity::Resolver.get_servers_for(domain)
+    end
+  end
+
+end

data/test/test_server.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TestServer < Test::Unit::TestCase
+
+  def test_creating_a_new_blank_server_object
+    new_server = EmailVeracity::Server.new
+    assert_equal '', new_server.to_s,
+      'Should yield a blank string on call to to_s.'
+    assert_equal '', new_server.name,
+      'Should yield a blank string on call to name.'
+  end
+
+  def test_creating_a_new_server_object_with_a_name_and_type
+    name = 'cooltown.ca'
+    new_server = EmailVeracity::Server.new(name)
+    assert_equal name, new_server.name,
+      'Should yield the provided name on call to name.'
+    assert_equal name, new_server.to_s,
+      'Should yield the provided name on call to to_s.'
+  end
+
+  def test_creating_a_new_blank_server_object_and_setting_its_name_after_initialization
+    new_server = EmailVeracity::Server.new('igvita.com')
+    assert_raise NoMethodError, 'Should fail miserably.' do
+      new_server.name = name
+    end
+  end
+
+end

data/test/test_utils.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class TestUtils < Test::Unit::TestCase
+
+  def test_blank
+    assert EmailVeracity::Utils.blank?([]), '[] should be blank.'
+    assert EmailVeracity::Utils.blank?(''), '"" should be blank.'
+    assert EmailVeracity::Utils.blank?(Hash.new), '{} should be blank.'
+    assert EmailVeracity::Utils.blank?(nil), 'nil should be blank.'
+  end
+
+end

data/test/test_validatability.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestValidatability < Test::Unit::TestCase
+
+  def test_includes_proper_methods
+    %w[ valid? validate! clear_errors! add_error errors ].each do |method_name|
+      assert_respond_to ClassWithValidationMock.new, method_name
+    end
+  end
+
+  def test_add_error
+    mock = ClassWithValidationMock.new
+    mock.give_error = true
+    assert_equal 1, mock.errors.size, 'Should set one error.'
+    mock.give_errors = true
+    assert_equal [:one, :two, :three], mock.errors,
+      'Should push tow new errors for a total of three.'
+    mock.give_array_of_errors = true
+    assert_equal [:one, :two, :three, :four, :five], mock.errors,
+      'Should concat the array leaving two new errors for a total of five.'
+  end
+
+  def test_valid?
+    mock = ClassWithValidationMock.new
+    assert mock.valid?, 'Should be valid by default.'
+    mock.give_error = true
+    assert !mock.valid?, 'Should not be valid if errors are set.'
+  end
+
+  def test_errors
+    assert ClassWithValidationMock.new.errors.empty?,
+      'Should be empty by default.'
+  end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: email_veracity
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Carsten Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.2
+    version: 
+description: Email Veracity abstracts an email address into a series of objects which makes it easy to see if an address is invalid, and if so, why.
+email: heycarsten@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- email_veracity.gemspec
+- lib/email_veracity.rb
+- lib/email_veracity/address.rb
+- lib/email_veracity/config.rb
+- lib/email_veracity/domain.rb
+- lib/email_veracity/resolver.rb
+- lib/email_veracity/server.rb
+- lib/email_veracity/utils.rb
+- lib/email_veracity/validatability.rb
+- test/helper.rb
+- test/test_address.rb
+- test/test_config.rb
+- test/test_domain.rb
+- test/test_resolver.rb
+- test/test_server.rb
+- test/test_utils.rb
+- test/test_validatability.rb
+has_rdoc: true
+homepage: http://github.com/heycarsten/email-veracity
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A simple library for checking the real-world validity of email addresses.
+test_files: 
+- test/helper.rb
+- test/test_address.rb
+- test/test_config.rb
+- test/test_domain.rb
+- test/test_resolver.rb
+- test/test_server.rb
+- test/test_utils.rb
+- test/test_validatability.rb