heycarsten-email-veracity 0.3.0

data/README.rdoc

@@ -0,0 +1,72 @@
+= 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.
+
+
+== 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.collect { |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.
+
+
+== Running The Tests
+
+A few of the tests will fail if you don't have a live connection to the
+internet, this is obviously not cool and it's high on my list of TODOs. [See
+TODO]

data/Rakefile

@@ -0,0 +1,93 @@
+# I used Haml as a template for these tasks: Thank you Nex3!
+require 'rubygems'
+require 'rake'
+
+
+task :default => :test
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+
+
+### Packaging
+require 'rake/gempackagetask'
+load    'email_veracity.gemspec'
+Rake::GemPackageTask.new(EMAIL_VERACITY_GEMSPEC) do |pkg|
+  if Rake.application.top_level_tasks.include?('release')
+    pkg.need_tar_gz = true
+    pkg.need_tar_bz2 = true
+    pkg.need_zip = true
+  end
+end
+
+
+task :revision_file do
+  require 'lib/email_veracity'
+
+  if EmailVeracity.version[:rev] && !Rake.application.top_level_tasks.include?('release')
+    File.open('REVISION', 'w') { |f| f.puts EmailVeracity.version[:rev] }
+  elsif Rake.application.top_level_tasks.include?('release')
+    File.open('REVISION', 'w') { |f| f.puts '(release)' }
+  else
+    File.open('REVISION', 'w') { |f| f.puts '(unknown)' }
+  end
+end
+Rake::Task[:package].prerequisites.insert(0, :revision_file)
+
+# We also need to get rid of this file after packaging.
+at_exit { File.delete('REVISION') rescue nil }
+
+
+task :install => [:package] do
+  sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
+  `#{sudo} gem install --no-ri pkg/email-veracity-#{File.read('VERSION').strip}`
+end
+
+
+task :release => [:package] do
+  name, version = ENV['NAME'], ENV['VERSION']
+  raise "Must supply NAME and VERSION for release task." unless name && version
+  `rubyforge login`
+  `rubyforge add_release email-veracity email-veracity "#{name} (v#{version})" pkg/email-veracity-#{version}.gem`
+  `rubyforge add_file    email-veracity email-veracity "#{name} (v#{version})" pkg/email-veracity-#{version}.tar.gz`
+  `rubyforge add_file    email-veracity email-veracity "#{name} (v#{version})" pkg/email-veracity-#{version}.tar.bz2`
+  `rubyforge add_file    email-veracity email-veracity "#{name} (v#{version})" pkg/email-veracity-#{version}.zip`
+end
+
+
+
+### Documentation
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.title    = 'Email Veracity'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include(*FileList.new('*') do |list|
+                            list.exclude(/(^|[^.a-z])[a-z]+/)
+                            list.exclude('TODO')
+                          end.to_a)
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.exclude('TODO')
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.main = 'README.rdoc'
+end
+
+
+
+### Coverage
+require 'rcov/rcovtask'
+
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.rcov_opts << '-x' << '"^\/"'
+  if ENV['NON_NATIVE']
+    t.rcov_opts << "--no-rcovrt"
+  end
+  t.verbose = true
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/init.rb

@@ -0,0 +1 @@
+require 'email_veracity'

data/lib/email_veracity.rb

@@ -0,0 +1,56 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+
+require 'resolv'
+require 'timeout'
+require 'email_veracity/core_extensions'
+require 'email_veracity/validatability'
+require 'email_veracity/errors'
+require 'email_veracity/config'
+require 'email_veracity/server'
+require 'email_veracity/resolver'
+require 'email_veracity/domain'
+require 'email_veracity/address'
+
+
+module EmailVeracity
+
+  def self.version # :nodoc:
+    return @@version if defined?(@@version)
+
+    numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
+
+    @@version = {
+      :major => numbers[0],
+      :minor => numbers[1],
+      :teeny => numbers[2] }
+
+    @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
+
+    if File.exists?(scope('REVISION'))
+      rev = File.read(scope('REVISION')).strip
+      rev = nil if rev !~ /[a-f0-9]+/
+    end
+
+    if rev.nil? && File.exists?(scope('.git/HEAD'))
+      rev = File.read(scope('.git/HEAD')).strip
+      if rev =~ /^ref: (.*)$/
+        rev = File.read(scope(".git/#{$1}")).strip
+      end
+    end
+
+    if rev
+      @@version[:rev] = rev
+      @@version[:string] << "." << rev[0...7]
+    end
+
+    @@version
+  end
+
+  def self.scope(file) # :nodoc:
+    File.join(File.dirname(__FILE__), '..', file)
+  end
+
+  VERSION = version[:string] unless defined?(EmailVeracity::VERSION)
+
+end

data/lib/email_veracity/address.rb

@@ -0,0 +1,41 @@
+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
+      @domain = Domain.new(@email_address.split('@')[1] || '')
+    end
+
+    protected
+      def validate!
+        add_error(:malformed) if !pattern_valid?
+        return unless Config[:lookup]
+        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,56 @@
+module EmailVeracity
+
+
+  class 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 => /\A(([\d\w\+_\-\.]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})){1}\Z/i,
+      :timeout => 2,
+      :lookup => [:a],
+      :enforce_blacklist => false,
+      :enforce_whitelist => true }
+    @options = DEFAULT_OPTIONS.clone
+
+    def Config.[](key)
+      @options[key.to_sym]
+    end
+
+    def Config.[]=(key, value)
+      @options[key.to_sym] = value
+    end
+
+    def Config.options
+      @options
+    end
+
+    def Config.options=(options)
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options must be a Hash not #{options.class}"
+      end
+      @options = options
+    end
+
+    def Config.update(options)
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options must be a Hash not #{options.class}"
+      end
+      @options.update(options)
+    end
+
+    def Config.enforce_lookup?(record)
+      return unless @options[:lookup].is_a?(Array)
+      @options[:lookup].any? { |i| i.to_s == record.to_s }
+    end
+
+    def Config.revert!
+      @options = DEFAULT_OPTIONS.clone
+    end
+
+  end
+
+
+end

data/lib/email_veracity/core_extensions.rb

@@ -0,0 +1,27 @@
+module EmailVeracity
+
+
+  class ::Array
+
+    def reject_blank_items
+      reject { |i| i.to_s.strip.blank? }
+    end
+
+    def contains_single_item?
+      size == 1
+    end
+
+  end
+
+
+  class ::Object
+
+    # Snaked from Rails.
+    def blank?
+      respond_to?(:empty?) ? empty? : !self
+    end
+
+  end
+
+
+end

data/lib/email_veracity/domain.rb

@@ -0,0 +1,69 @@
+module EmailVeracity
+
+
+  class Domain
+
+    include Validatability
+
+    def Domain.whitelisted?(name)
+      Config[:whitelist].include?(name.downcase.strip)
+    end
+
+    def Domain.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_address_servers) if address_servers.empty? &&
+          Config.enforce_lookup?(:a)
+        add_error(:no_exchange_servers) if exchange_servers.empty? &&
+          Config.enforce_lookup?(:mx)
+      end
+
+      def servers_in(record)
+        return [] if name.blank?
+        Resolver.get_servers_for(name, record)
+       rescue DomainResourcesTimeoutError
+        add_error :timed_out
+      end
+
+  end
+
+
+end

data/lib/email_veracity/errors.rb

@@ -0,0 +1,9 @@
+module EmailVeracity
+
+
+  class Error < StandardError; end
+  class MalformedEmailAddressError < Error; end
+  class DomainResourcesTimeoutError < Error; end
+
+
+end

data/lib/email_veracity/resolver.rb

@@ -0,0 +1,46 @@
+module EmailVeracity
+
+
+  class 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 Resolver.get_servers_for(domain_name, record = :a)
+      Timeout::timeout(Config[:timeout]) do
+        get_resources_for(domain_name, record).collect 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 Resolver.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 Resolver.resources_to_servers(resources, resolve_method)
+        resources.inject([]) do |array, resource|
+          array << resource.method(resolve_method).call.to_s.strip
+        end.reject_blank_items
+      end
+
+  end
+
+
+end

data/lib/email_veracity/server.rb

@@ -0,0 +1,20 @@
+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/validatability.rb

@@ -0,0 +1,34 @@
+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/test/mocks/class_with_validation_mock.rb

@@ -0,0 +1,16 @@
+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

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'lib/email_veracity'
+Dir.glob('test/mocks/*.rb') { |f| require(f) }
+
+
+class Test::Unit::TestCase
+
+  def domain_names
+    %w[ viarails.net  heycarsten.com  yahoo.com  gmail.com  savvica.com
+      learnhub.com  github.com  google.com  rogers.com  amd.com  adobe.com
+      unspace.ca  xerox.com  webkit.org  cooltown.net  aiderss.com
+      del.icio.us ]
+  end
+
+  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/unit/address_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class AddressTest < 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,
+      'Should errors should be an array.'
+  end
+
+end
+
+
+class DefaultConfigurationAddressValidationsTest < Test::Unit::TestCase
+
+  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')
+    assert address.valid?,
+      "Should 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')
+    assert !address.valid?,
+      'Should not be valid.'
+  end
+
+  def test_a_well_formed_address_that_exists
+    address = new_address('itsme@heycarsten.com')
+    assert address.valid?,
+      "Should be valid. @errors: #{address.errors.inspect}"
+  end
+
+  private
+    def new_address(address = '')
+      EmailVeracity::Address.new(address)
+    end
+
+end

data/test/unit/config_test.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class ConfigTest < Test::Unit::TestCase
+
+  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_lookup_default_setting
+    assert_instance_of Array, EmailVeracity::Config[:lookup]
+  end
+
+  def test_enforce_lookup_with_symbols
+    assert EmailVeracity::Config.enforce_lookup?(:a),
+      'Should check for A records by default'
+    assert !EmailVeracity::Config.enforce_lookup?(:mx),
+      'Should not check for MX records be default'
+  end
+
+  def test_enforce_lookup_with_strings
+    assert EmailVeracity::Config.enforce_lookup?('a'),
+      'Should check for A records by default'
+    assert !EmailVeracity::Config.enforce_lookup?('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
+
+
+class DefaultValidAddressPatternTest < Test::Unit::TestCase
+
+  def test_default_valid_address_pattern
+    assert_instance_of Regexp, EmailVeracity::Config[:valid_pattern],
+      'Should exist as a regular expression.'
+  end
+
+  def test_valid_email_addresses
+    %w[
+      goto@rubyfringe.ca
+      stuff+heyd00d@gmail.com
+      carsten_nielsen@gmail.com
+      carsten-nielsen@gmail.com
+      iwenttowestern@ivyleague.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
+      jesus@god.com
+      neat@b.eat
+    ].each do |address|
+      assert_match EmailVeracity::Config[:valid_pattern],
+        address,
+        "#{address} should be valid."
+    end
+  end
+
+  def test_invalid_email_addresses
+    %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
+    ].each do |address|
+      assert_no_match EmailVeracity::Config[:valid_pattern],
+        address,
+        "#{address} should be invalid."
+    end
+  end
+
+end

data/test/unit/core_extensions_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class ArrayExtensionsTest < Test::Unit::TestCase
+
+  def test_reject_blank_items
+    array = [[], {}, '', nil, '    ', 'good times!']
+    assert_equal ['good times!'], array.reject_blank_items, 'Should reject all blank and empty objects.'
+    array = [{:neat => 'o'}, ['cool'], 1, 's']
+    assert_equal array, array.reject_blank_items, 'Should not reject any filled or not-blank objects.'
+  end
+
+  def test_contains_single_item
+    assert [''].contains_single_item?, 'Should contain one item.'
+    assert [nil].contains_single_item?, 'Should contain one item.'
+    assert [[]].contains_single_item?, 'Should contain one item.'
+    assert ![].contains_single_item?, 'Should not contain one item.'
+    assert ![nil, false].contains_single_item?, 'Should not contain one item.'
+  end
+
+  def test_blank
+    assert [].blank?, '[] should be blank.'
+    assert ''.blank?, '"" should be blank.'
+    assert Hash.new.blank?, '{} should be blank.'
+    assert nil.blank?, 'nil should be blank.'
+  end
+
+end

data/test/unit/domain_test.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class DomainTest < 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_servers
+    domain = new_domain('gmail.com')
+    assert_not_empty domain.exchange_servers, 'Should contain mail servers.'
+    assert_not_empty domain.address_servers, 'Should contain address servers.'
+  end
+
+  def test_a_valid_domain_with_whitespace_for_servers
+    domain = new_domain('  learnhub.com  ')
+    assert_not_empty domain.exchange_servers, 'Should contain mail servers.'
+    assert_not_empty domain.address_servers, 'Should contain address servers.'
+  end
+
+  def test_an_invalid_domain_for_servers
+    domain = new_domain('i-surely-do-not.exist')
+    assert_empty domain.exchange_servers, 'Should not contain exchange servers.'
+    assert_empty domain.address_servers, 'Should not contain address 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
+
+  def test_for_errors_on_an_invalid_domain
+    domain = new_domain('i-surely-do-not.exist')
+    assert_not_empty domain.errors, 'Should have errors.'
+  end
+
+  private
+    def new_domain(name = 'heycarsten.com')
+      EmailVeracity::Domain.new(name)
+    end
+
+end

data/test/unit/resolver_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class ResolverTest < Test::Unit::TestCase
+
+  def test_consecutive_queries
+    EmailVeracity::Config[:timeout] = 60
+    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
+    EmailVeracity::Config[:timeout] = 0.001
+    assert_raise EmailVeracity::DomainResourcesTimeoutError, 'Should time out' do
+      EmailVeracity::Resolver.get_servers_for('learnhub.com')
+    end
+    EmailVeracity::Config[:timeout] = 2
+  end
+
+end

data/test/unit/server_test.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class ServerTest < 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/unit/validatability_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+
+class ValidatabilityTest < 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,78 @@
+--- !ruby/object:Gem::Specification 
+name: heycarsten-email-veracity
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Carsten Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+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: 
+- README.rdoc
+files: 
+- lib/email_veracity/address.rb
+- lib/email_veracity/config.rb
+- lib/email_veracity/core_extensions.rb
+- lib/email_veracity/domain.rb
+- lib/email_veracity/errors.rb
+- lib/email_veracity/resolver.rb
+- lib/email_veracity/server.rb
+- lib/email_veracity/validatability.rb
+- lib/email_veracity.rb
+- README.rdoc
+- VERSION
+- Rakefile
+- init.rb
+has_rdoc: true
+homepage: http://github.com/heycarsten/email-veracity
+post_install_message: 
+rdoc_options: 
+- --title
+- Email Veracity
+- --main
+- README.rdoc
+- --line-numbers
+- --inline-source
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A simple library for checking the real-world validity of email addresses.
+test_files: 
+- test/mocks/class_with_validation_mock.rb
+- test/test_helper.rb
+- test/unit/address_test.rb
+- test/unit/config_test.rb
+- test/unit/core_extensions_test.rb
+- test/unit/domain_test.rb
+- test/unit/resolver_test.rb
+- test/unit/server_test.rb
+- test/unit/validatability_test.rb