Refactored tests, added test data, improved the extractor regex.

* Test data now stored in input => expected_output structure
* new test input/output added easily w/ the test_input helper
* each test iterates over all of the test data
* added a few new address formats to the tests, improved regex to recognize those additional formats.

Author: coderifous

lib/address_extractor.rb

@@ -152,7 +152,7 @@ def useful_address?(hash)
     (
       \d+                           # A few numbers
       \s+
-      (?:[A-Za-z'.-]+\s?){1,3}      # Followed by a street name
+      (?:[A-Za-z'.-]+\s?){0,2} (?:[A-Za-z'.-]+) # Followed by a street name
     )
     \s* ,?  \s*                     
     (
@@ -163,8 +163,8 @@ def useful_address?(hash)
     \s* ,?  \s*                     # a comma, optionally
     (?:
       (?:
-        ((?:[A-Za-z]+\s?){1,3})     # city
-        \s+
+        ( (?:[A-Za-z]+\s?){0,2} (?:[A-Za-z]+) ) # city
+        \s* ,?  \s*                 # a comma, optionally
         \b(#{STATE_REGEX})\b        # state
         \s* ,? \s*                  # a comma, optionally
         (\d{6})?                    # a zip code, optionally

test/test_address_extractor.rb

@@ -2,77 +2,79 @@
 
 require 'test/unit'
 require 'address_extractor.rb'
+require 'test_helper.rb'
+include TestDataHelper
 
 class AddressExtractorTest < Test::Unit::TestCase
+  include Helpers
 
   def test_first_address_extraction
-    address = AddressExtractor.first_address(DATA1)
-    assert_first_address(address)
+    each_test_data do |test_data|
+      address = AddressExtractor.first_address(test_data[:input])
+      flunk "No address found in:\n#{test_data[:input]}" if address.nil?
+      assert_equal_hashes address, test_data[:expected_output].first
+    end
   end
 
   def test_find_addresses
-    addresses = AddressExtractor.find_addresses(DATA1)
-    assert_first_address  addresses[0]
-    assert_second_address addresses[1]
+    each_test_data do |test_data|
+      addresses = AddressExtractor.find_addresses(test_data[:input])
+      assert_equal addresses.size, test_data[:expected_output].size
+      test_data[:expected_output].each do |expected_output|
+        assert_equal_hashes addresses.shift, expected_output
+      end
+    end
   end
 
   def test_replace_first_address
-    string = AddressExtractor.replace_first_address(DATA1) do |address_hash, address|
-      assert_first_address address_hash
-      assert_first_address_string address
+    string = AddressExtractor.replace_first_address(test_data.first[:input]) do |address_hash, address|
+      assert_equal_hashes address_hash, test_data.first[:expected_output].first
+      assert_match /^\s*123 Foo St., Someplace FL\s*/, address 
       "skidoosh"
     end
     assert string =~ /Please send the package to skidoosh/
   end
-  
+
   def test_replace_addresses
-    string = AddressExtractor.replace_addresses(DATA1) do |address_hash, address|
+    string = AddressExtractor.replace_addresses(test_data.first[:input]) do |address_hash, address|
       "skidoosh"
     end
     assert string =~ /Please send the package to skidoosh/
-    assert string =~ /via mail at:\n  skidoosh/
+    assert string =~ /via mail at:\s+skidoosh/
   end
-  
+
   def test_no_addresses_found
     assert_nil AddressExtractor.first_address("foo")
     assert_equal [], AddressExtractor.find_addresses("foo")
     assert_equal "foo", AddressExtractor.replace_first_address("foo")
     assert_equal "foo", AddressExtractor.replace_addresses("foo")
   end
-  
-  module Helpers
-    def assert_first_address(a)
-      assert_not_nil a
-      assert_equal "123 Foo St.", a[:street1]
-      assert_equal nil,           a[:street2]
-      assert_equal "Someplace",   a[:city]
-      assert_equal "FL",          a[:state]
-      assert_equal nil,           a[:zip]
-    end
-  
-    def assert_first_address_string(string)
-      assert_match /^123 Foo St\., Someplace FL\s*$/, string
-    end
-  
-  
-    def assert_second_address(a)
-      assert_not_nil a
-      assert_equal "123 Goob Avenue", a[:street1]
-      assert_equal "Apt 123",         a[:street2]
-      assert_equal "Nice Town",       a[:city]
-      assert_equal "CA",              a[:state]
-      assert_equal "123456",          a[:zip]
-    end
-  end
-  include Helpers
 end
 
-DATA1 = <<EOF
-Please send the package to 123 Foo St., Someplace FL
+# Test Input/Expected outputs defined below using test_input helper
+# Expanding the tests will probably start with adding new test input
+
+test_input "
+    Please send the package to 123 Foo St., Someplace FL
+
+    My phone number is 123-1234 and St. Marc of Israel can be reached
+    via mail at:
+      123 Goob Avenue
+      Apt 123
+      Nice Town CA 123456
+  ",
+  { :street1 => "123 Foo St.", :street2 => nil, :city => "Someplace", :state => "FL", :zip => nil },
+  { :street1 => "123 Goob Avenue", :street2 => "Apt 123", :city => "Nice Town", :state => "CA", :zip => "123456" }
+
+test_input "Let's meet tomorrow at noon at 123 Foo Bar Street, Scooby NY 123456",
+  { :street1 => "123 Foo Bar Street", :street2 => nil, :city => "Scooby", :state => "NY", :zip => "123456" }
+
+test_input "Let's meet tomorrow at noon at 123 Foo Bar Street, Scooby, NY 123456",
+  { :street1 => "123 Foo Bar Street", :street2 => nil, :city => "Scooby", :state => "NY", :zip => "123456" }
+  
+test_input "Let's meet tomorrow at noon at 123 Foo Bar Street, Scooby, NY, 123456",
+  { :street1 => "123 Foo Bar Street", :street2 => nil, :city => "Scooby", :state => "NY", :zip => "123456" }
+
+test_input "Let's meet tomorrow at noon at 123 Foo Bar Street, 123456",
+  { :street1 => "123 Foo Bar Street", :street2 => nil, :city => nil, :state => nil, :zip => "123456" }
 
-My phone number is 123-1234 and St. Marc of Israel can be reached
-via mail at:
-  123 Goob Avenue
-  Apt 123
-  Nice Town CA 123456
-EOF

test/test_helper.rb

@@ -0,0 +1,31 @@
+module TestDataHelper
+
+  TEST_DATA = []
+
+  def test_input(input_string, *expected_outputs)
+    test_data << { :input => input_string, :expected_output => expected_outputs }
+  end
+
+  def each_test_data
+    test_data.each { |t| yield(t) }
+  end
+  
+  def test_data
+    TEST_DATA
+  end
+  
+end
+
+module Helpers
+
+  def assert_equal_hashes(a,b)
+    (a.keys + b.keys).uniq.each do |k|
+      assert_equal a[k], b[k], "a[#{k.inspect}] = #{a[k].inspect} != b[#{k.inspect}] = #{b[k].inspect}"
+    end
+  end
+
+  def assert_first_address_string(string)
+    assert_match /^123 Foo St\., Someplace FL\s*$/, string
+  end
+  
+end