activewarehouse-etl-sgonyea 0.9.6

data/test/nokogiri_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test the flat text parsers
+class ParserTest < Test::Unit::TestCase
+
+  # Test the DOM-based Nokogiri XML parser. .
+  def test_nokogiri_xml_parser_for_all_nodes
+    control = ETL::Control::Control.resolve(
+      File.dirname(__FILE__) + '/nokogiri_all.ctl')
+    parser = ETL::Parser::NokogiriXmlParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    assert_equal 3, rows.length
+    assert_equal(
+      { :hair_colour=>"black",
+        :first_name=>"Bob", 
+        :last_name=>"Smith", 
+        :ssn=>"123456789", :age=>"24"}, rows.first)
+  end
+
+  # Test the DOM-based Nokogiri XML parser. .
+  def test_nokogiri_xml_parser_for_selected_nodes
+    control = ETL::Control::Control.resolve(
+      File.dirname(__FILE__) + '/nokogiri_select.ctl')
+    parser = ETL::Parser::NokogiriXmlParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    assert_equal 2, rows.length
+    assert_equal(
+      { :age=>"37",
+        :hair_colour=>"black",
+        :first_name=>"Jake",
+        :last_name=>"Smithsonian",
+        :ssn=>"133244566"}, rows.last)
+  end
+
+end

data/test/parser_test.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test the flat text parsers
+class ParserTest < Test::Unit::TestCase
+  # Test parsing delimited data
+  def test_csv_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/delimited.ctl')
+    parser = ETL::Parser::CsvParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    assert_equal 3, rows.length
+    assert_equal({:first_name=>"Chris", :last_name=>"Smith", :ssn=>"111223333", :age=>"24", :sex => 'M'}, rows.first)
+  end
+  
+  # Test parsing fixed-width data
+  def test_fixed_width_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/fixed_width.ctl')
+    parser = ETL::Parser::FixedWidthParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    assert_equal 3, rows.length
+    assert_equal({:first_name=>"Bob", :last_name=>"Smith", :ssn=>"123445555", :age=>"23"}, rows.first)
+  end
+  
+  # Test the DOM-based XML parser. Note that the DOM parser is slow and should
+  # probably be removed.
+  def test_xml_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/xml.ctl')
+    parser = ETL::Parser::XmlParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    assert_equal 2, rows.length
+    assert_equal({:first_name=>"Bob", :last_name=>"Smith", :ssn=>"123456789", :age=>"24"}, rows.first)
+  end
+  
+  # Test an inline parser
+  def test_inline_parser
+    ETL::Engine.process(File.dirname(__FILE__) + '/inline_parser.ctl')
+    lines = open(File.dirname(__FILE__) + '/output/inline_parser.txt').readlines
+    assert_equal 3, lines.length
+  end
+  
+  # Test the SAX parser (preferred for XML parsing)
+  def test_sax_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/sax.ctl')
+    parser = control.sources.first.parser
+    rows = parser.collect { |row| row }
+    assert_equal 2, rows.length
+    assert_equal({:first_name=>"Bob", :last_name=>"Smith", :ssn=>"123456789", :age=>"24"}, rows.first)
+  end
+
+  # Test the Excel parser
+  def test_excel_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/excel.ctl')
+    parser = control.sources.first.parser
+    rows = parser.collect { |row| row }
+    assert_equal 2, rows.length
+    assert_equal({:first_name=>"Bob", :last_name=>"Smith", :ssn=>123456789, :age=>24}, rows.first)
+  end
+  
+  # Test 2 the Excel parser
+  def test_excel2_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/excel2.ctl')
+    parser = control.sources.first.parser
+    rows = parser.collect { |row| row }
+    assert_equal 2, rows.length
+    assert_equal({:first_name=>"John", :last_name=>"Doe", :ssn=>222114545, :age=>31}, rows[1])
+  end
+  
+  # Test the Apache combined log format parser
+  def test_apache_combined_log_parser
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/apache_combined_log.ctl')
+    parser = ETL::Parser::ApacheCombinedLogParser.new(control.sources.first)
+    # first test the parse method
+    line = %Q(127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326 "http://www.example.com/start.html" "Mozilla/4.08 [en] (Win98; I ;Nav)")
+    fields = parser.parse(line)
+    assert_equal '127.0.0.1', fields[:ip_address]
+    assert_equal 'frank', fields[:user]
+    assert_equal Time.mktime(2000, 10, 10, 13, 55, 36), fields[:timestamp]
+    assert_equal 'GET /apache_pb.gif HTTP/1.0', fields[:request]
+    assert_equal '200', fields[:response_code]
+    assert_equal '2326', fields[:bytes]
+    assert_equal 'http://www.example.com/start.html', fields[:referrer]
+    assert_equal 'Mozilla/4.08 [en] (Win98; I ;Nav)', fields[:user_agent]
+    #now test the each method
+    rows = parser.collect { |row| row }
+    assert_equal 3, rows.length
+    assert_equal({
+      :user_agent=>"Mozilla/4.08 [en] (Win98; I ;Nav)",
+      :browser_version_minor=>nil,
+      :timestamp=>Time.mktime(2000, 10, 10, 13, 55, 36),
+      :ostype=>"Windows",
+      :request=>"GET /apache_pb.gif HTTP/1.0",
+      :referrer_host=>"www.example.com",
+      :referrer_domain=>"example.com",
+      :os=>"Win98",
+      :referrer_uri_path=>"/start.html",
+      :method=>"GET",
+      :response_code=>"200",
+      :referrer_port=>80,
+      :os_version=>nil,
+      :ip_address=>"127.0.0.1",
+      :referrer_scheme=>"http",
+      :bytes=>"2326",
+      :browser=>"Mozilla",
+      :identd=>nil,
+      :path=>"/apache_pb.gif",
+      :referrer=>"http://www.example.com/start.html",
+      :browser_version_major=>"4",
+      :user=>"frank"}, rows.first, 'Failed on first row')
+    assert_equal({
+      :user_agent=>"Mozilla/4.08 [en] (Win98; I ;Nav)",
+      :referrer_port=>80,
+      :timestamp=>Time.mktime(2000, 10, 11, 5, 22, 2),
+      :browser_version_minor=>nil,
+      :os_version=>nil,
+      :request=>"GET /apache_pb.gif HTTP/1.1",
+      :ostype=>"Windows",
+      :referrer_scheme=>"http",
+      :response_code=>"200",
+      :referrer_host=>"www.foo.com",
+      :referrer_domain=>"foo.com",
+      :ip_address=>"127.0.0.1",
+      :browser=>"Mozilla",
+      :bytes=>"2326",
+      :os=>"Win98",
+      :identd=>nil,
+      :browser_version_major=>"4",
+      :referrer=>"http://www.foo.com/",
+      :referrer_uri_path=>"/",
+      :method=>"GET",
+      :path=>"/apache_pb.gif",
+      :user=>"bob"}, rows[1], 'Failed on second row')
+    assert_equal({
+      :browser_version_major=>"4",
+      :browser_version_minor=>nil,
+      :referrer_port=>nil,
+      :request=>"GET /apache_pb.gif HTTP/1.1",
+      :ostype=>"Windows",
+      :os_version=>nil,
+      :response_code=>"200",
+      :referrer_host=>nil,
+      :referrer_scheme=>nil,
+      :bytes=>"2326",
+      :ip_address=>"127.0.0.1",
+      :browser=>"Mozilla",
+      :referrer=>nil,
+      :os=>"Win98",
+      :user=>"bob",
+      :user_agent=>"Mozilla/4.08 [en] (Win98; I ;Nav)",
+      :identd=>nil,
+      :referrer_uri_path=>nil,
+      :path=>"/apache_pb.gif",
+      :method=>"GET",
+      :timestamp=>Time.mktime(2000, 10, 11, 5, 52, 31)}, rows[2], 'Failed on third row')
+  end
+  
+  # Test the user agent parser
+  def test_user_agent_parser
+    agents = <<-AGENTS
+      Mozilla/4.7 [en] (WinNT; U)
+      Mozilla/4.0 (compatible; MSIE 5.01; Windows NT)
+      Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; T312461; .NET CLR 1.1.4322)
+      Mozilla/4.0 (compatible; MSIE 5.0; Windows NT 4.0) Opera 5.11 [en]
+      Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.0.2) Gecko/20030208 Netscape/7.02
+      Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.6) Gecko/20040612 Firefox/0.8
+      Mozilla/5.0 (compatible; Konqueror/3.2; Linux) (KHTML, like Gecko)
+      Lynx/2.8.4rel.1 libwww-FM/2.14 SSL-MM/1.4.1 OpenSSL/0.9.6h
+    AGENTS
+    agents = agents.split("\n").collect { |s| s.strip }
+
+    control = ETL::Control::Control.resolve(File.dirname(__FILE__) + '/apache_combined_log.ctl')
+    parser = ETL::Parser::ApacheCombinedLogParser.new(control.sources.first)
+    rows = parser.collect { |row| row }
+    
+    assert_equal({:browser_version_major=>"4",
+      :browser_version_minor=>nil,
+      :ostype=>"Windows",
+      :os=>"WinNT",
+      :os_version=>nil,
+      :browser=>"Mozilla"}, parser.parse_user_agent(agents[0]), 'Agent 0 invalid'
+    )
+    assert_equal({:browser_version_major=>"5",
+      :browser_version_minor=>"01",
+      :ostype=>"Windows",
+      :os=>"Windows NT",
+      :os_version=>nil,
+      :browser=>"MSIE"}, parser.parse_user_agent(agents[1]), 'Agent 1 invalid'
+    )
+    assert_equal({:browser_version_major=>"6",
+      :browser_version_minor=>"0",
+      :ostype=>"Windows",
+      :os=>"Windows NT 5.0",
+      :os_version=>"5.0",
+      :browser=>"MSIE"}, parser.parse_user_agent(agents[2]), 'Agent 2 invalid'
+    )
+    assert_equal({:browser_version_major=>"5",
+      :browser_version_minor=>"0",
+      :ostype=>"Windows",
+      :os=>"Windows NT 4.0",
+      :os_version=>"4.0",
+      :browser=>"MSIE"}, parser.parse_user_agent(agents[3]), 'Agent 3 invalid'
+    )
+    assert_equal({:browser_version_major=>"7",
+      :browser_version_minor=>nil,
+      :ostype=>"Windows",
+      :os=>"Windows NT 5.0",
+      :os_version=>"5.0",
+      :browser=>"Netscape"}, parser.parse_user_agent(agents[4]), 'Agent 4 invalid'
+    )
+    assert_equal({:browser_version_major=>"0.8",
+      :browser_version_minor=>nil,
+      :ostype=>"Linux",
+      :os=>"Linux i686",
+      :os_version=>nil,
+      :browser=>"Firefox"}, parser.parse_user_agent(agents[5]), 'Agent 5 invalid'
+    )
+    # test fails here
+    # assert_equal({:browser_version_major=>"6",
+#       :browser_version_minor=>nil,
+#       :ostype=>"Linux",
+#       :os=>"Linux",
+#       :os_version=>nil,
+#       :browser=>"Konquerer"}, parser.parse_user_agent(agents[6]), 'Agent 6 invalid'
+#     )
+  end
+end

data/test/performance/delimited.ctl

@@ -0,0 +1,30 @@
+# puts "executing delimited.ctl"
+
+source :in, {
+  :file => 'delimited.txt',
+  :parser => :csv
+}, 
+[ 
+  :first_name,
+  :last_name,
+  :ssn,
+  {
+    :name => :age,
+    :type => :integer
+  },
+  :sex
+]
+
+transform :ssn, :sha1
+transform(:ssn){ |v| v[0,24] }
+transform :sex, :decode, {:decode_table_path => 'delimited_decode.txt'}
+
+destination :out, {
+  :file => 'delimited.out.txt'
+},
+{
+  :order => [:first_name, :last_name, :name, :ssn, :age, :sex],
+  :virtual => {
+    :name => Proc.new { |row| "#{row[:first_name]} #{row[:last_name]}" }
+  }
+}

data/test/processor_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Person < ActiveRecord::Base
+end
+
+# Test pre- and post-processors
+class ProcessorTest < Test::Unit::TestCase
+  # Test bulk import functionality
+  
+  context "the bulk import processor" do
+    should "should import successfully" do
+      assert_nothing_raised { do_bulk_import }
+      assert_equal 3, Person.count
+      assert_equal "Foxworthy", Person.find(2).last_name
+    end
+  end
+  
+  def test_bulk_import_with_empties
+    # this test ensure that one column with empty value will still allow
+    # the row to be imported
+    # this doesn't apply to the id column though - untested
+    assert_nothing_raised { do_bulk_import('bulk_import_with_empties.txt') }
+    assert_equal 3, Person.count
+    assert Person.find(2).last_name.blank?
+  end
+
+  def test_truncate
+    # TODO: implement test
+  end
+  
+  private
+  
+  def do_bulk_import(file = 'bulk_import.txt')
+    control = ETL::Control::Control.new(File.join(File.dirname(__FILE__), 'delimited.ctl'))
+    configuration = {
+      :file => "data/#{file}",
+      :truncate => true,
+      :target => :data_warehouse,
+      :table => 'people'
+    }
+    processor = ETL::Processor::BulkImportProcessor.new(control, configuration)
+    processor.process
+  end
+end

data/test/row_processor_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test row processors
+class RowProcessorTest < Test::Unit::TestCase
+  def test_copy_field_processor
+    
+  end
+  def test_hierarchy_exploder_processor
+    
+  end
+  def test_rename_processor
+    
+  end
+  def test_sequence_processor
+    
+  end
+end

data/test/sax.ctl

@@ -0,0 +1,26 @@
+# puts "executing fixed_width.ctl"
+
+source :in, {
+  :file => 'data/sax.xml',
+  :parser => :sax
+}, 
+{
+  :write_trigger => 'people/person',
+  :fields => {
+    :first_name => 'people/person/first_name',
+    :last_name => 'people/person/last_name',
+    :ssn => 'people/person/social_security_number',
+    :age => 'people/person[age]'
+  }
+}
+
+transform :ssn, :sha1
+transform(:ssn){ |v| v[0,24] }
+transform :age, :type, {:type => :number}
+
+destination :out, {
+  :file => 'output/sax.out.txt'
+}, 
+{
+  :order => [:first_name, :last_name, :ssn, :age]
+}

data/test/scd/1.txt

@@ -0,0 +1 @@
+Bob,Smith,200 South Drive,Boston,MA,32123

data/test/scd/2.txt

@@ -0,0 +1 @@
+Bob,Smith,1010 SW 23rd St,Los Angeles,CA,90392

data/test/scd/3.txt

@@ -0,0 +1 @@
+Bob,Smith,280 Pine Street,Los Angeles,CA,90392

data/test/scd_test.rb

@@ -0,0 +1,257 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ScdTest < Test::Unit::TestCase
+  context "when working with a slowly changing dimension" do
+    setup do
+      @connection = ETL::Engine.connection(:data_warehouse)
+      @connection.delete("DELETE FROM person_dimension")
+      @end_of_time = DateTime.parse('9999-12-31 00:00:00')
+    end
+    context "of type 1" do
+      context "on run 1" do
+        setup do
+          do_type_1_run(1)
+        end
+        should "insert record" do
+          assert_equal 1, count_bobs
+        end
+        should "set the original address" do
+          assert_boston_address(find_bobs.first)
+        end
+        should "set the original id" do
+          assert_equal 1, find_bobs.first.id
+        end
+        should "skip the load if there is no change" do
+          do_type_1_run(1)
+          lines = lines_for('scd_test_type_1.txt')
+          assert lines.empty?, "scheduled load expected to be empty, was #{lines.size} records"
+        end
+      end
+      context "on run 2" do
+        setup do
+          do_type_1_run(1)
+          do_type_1_run(2)
+        end
+        should "delete the old record" do
+          assert_equal 1, count_bobs, "new record created, but old not deleted: #{find_bobs.inspect}"
+        end
+        should "update the address" do
+          assert_los_angeles_address(find_bobs.last)
+        end
+        should "keep id" do
+          assert_equal 1, find_bobs.first.id
+        end
+        should "only change once even if run again" do
+          do_type_1_run(2)
+          assert_equal 1, count_bobs
+          lines = lines_for('scd_test_type_1.txt')
+          assert lines.empty?, "scheduled load expected to be empty, was #{lines.size} records"
+        end
+        should "revert address on new record" do
+          do_type_1_run(1)
+          assert_boston_address(find_bobs.first)
+        end
+        should "keep record on revert" do
+          do_type_1_run(1)
+          assert_equal 1, count_bobs
+        end
+      end
+    end
+    context "of type 2" do
+      context "on run 1" do
+        setup do
+          do_type_2_run(1)
+        end
+        should "insert record" do
+          assert_equal 1, count_bobs
+        end
+        should "set the original record" do
+          assert_boston_address(find_bobs.first)
+        end
+        should "set the original id" do
+          assert_equal 1, find_bobs.first.id
+        end
+        should "set the effective date" do
+          # doing comparison on strings, as comparison on objects
+          # doesn't consider things equal for some yet to be understood
+          # reason
+          assert_equal current_datetime.to_s, find_bobs.first.effective_date.to_s
+        end
+        should "set the end date" do
+          assert_equal @end_of_time, find_bobs.first.end_date
+        end
+        should "set the latest version flag" do
+          assert find_bobs.first.latest_version?
+        end
+        should "skip the load if there is no change" do
+          do_type_2_run(1)
+          assert_equal 1, find_bobs.last.id, "scheduled load expected to be empty"
+        end
+        
+      end
+      context "on run 2" do
+        setup do
+          do_type_2_run(1)
+          do_type_2_run(2)
+        end
+        should "insert new record" do
+          assert_equal 2, count_bobs
+        end
+        should "keep the primary key of the original version" do
+          assert_not_nil find_bobs.detect { |bob| 1 == bob.id }
+        end
+        should "increment the primary key for the new version" do
+          assert_not_nil find_bobs.detect { |bob| 2 == bob.id }
+        end
+        should "expire the old record" do
+          original_bob = find_bobs.detect { |bob| 1 == bob.id }
+          new_bob = find_bobs.detect { |bob| 2 == bob.id }
+          assert_equal new_bob.effective_date, original_bob.end_date
+        end
+        should "keep the address for the expired record" do
+          assert_boston_address(find_bobs.detect { |bob| 1 == bob.id })
+        end
+        should "update the address on the new record" do
+          assert_los_angeles_address(find_bobs.detect { |bob| 2 == bob.id })
+        end
+        should "activate the new record" do
+          # doing comparison on strings, as comparison on objects
+          # doesn't consider things equal for some yet to be understood
+          # reason
+          assert_equal current_datetime.to_s, find_bobs.detect { |bob| 2 == bob.id }.effective_date.to_s
+        end
+        should "set the end date for the new record" do
+          assert_equal @end_of_time, find_bobs.detect { |bob| 2 == bob.id }.end_date
+        end
+        should "shift the latest version" do
+          original_bob = find_bobs.detect { |bob| 1 == bob.id }
+          new_bob = find_bobs.detect { |bob| 2 == bob.id }
+          assert !original_bob.latest_version?
+          assert new_bob.latest_version?
+        end
+        should "only execute a change once" do
+          do_type_2_run(2)
+          assert_equal 2, count_bobs, "scheduled load expected to be empty"
+        end
+        should "insert new records on revert" do
+          do_type_2_run(1)
+          assert_equal 3, count_bobs
+        end
+        should "update address on new record on revert" do
+          do_type_2_run(1)
+          assert_boston_address(find_bobs.detect { |bob| 3 == bob.id })
+        end
+        should "only delete one row on an scd change" do
+          # Two records right now
+          assert_equal 2, count_bobs
+          do_type_2_run(1) # put third version in (same as first version, but that's irrelevant)
+          # was failing because first and second versions were being deleted.
+          assert_equal 3, count_bobs
+        end
+      end
+      context "on non sdc fields that change" do
+        setup do
+          do_type_2_run_with_only_city_state_zip_scd(1)
+          do_type_2_run_with_only_city_state_zip_scd(2)
+        end
+        should "not create an extra record" do
+          do_type_2_run_with_only_city_state_zip_scd(3)
+          assert_equal 2, count_bobs
+        end
+        should "keep id" do
+          do_type_2_run_with_only_city_state_zip_scd(3)
+          assert_not_nil find_bobs.detect { |bob| 2 == bob.id }
+        end
+        should "keep dates" do
+          old_bob = find_bobs.detect { |bob| 2 == bob.id }
+          do_type_2_run_with_only_city_state_zip_scd(3)
+          new_bob = find_bobs.detect { |bob| 2 == bob.id }
+          assert_equal old_bob.end_date, new_bob.end_date
+          assert_equal old_bob.effective_date, new_bob.effective_date
+        end
+        should "keep the latest version flag" do
+          do_type_2_run_with_only_city_state_zip_scd(3)
+          assert find_bobs.detect { |bob| 2 == bob.id }.latest_version?
+        end
+        should "treat non scd fields like type 1 fields" do
+          do_type_2_run_with_only_city_state_zip_scd(3)
+          assert_los_angeles_address(find_bobs.detect { |bob| 2 == bob.id }, "280 Pine Street")
+        end
+        should "skip load when there is no change" do
+          do_type_2_run_with_only_city_state_zip_scd(2)
+          assert_equal 2, count_bobs, "scheduled load expected to be empty"
+        end
+      end
+    end
+  end
+  
+  def do_type_2_run(run_num)
+    ENV['run_number'] = run_num.to_s
+    assert_nothing_raised do
+      run_ctl_file("scd_test_type_2.ctl")
+    end
+  end
+  
+  def do_type_2_run_with_only_city_state_zip_scd(run_num)
+    ENV['type_2_scd_fields'] = Marshal.dump([:city, :state, :zip_code])
+    do_type_2_run(run_num)
+  end
+  
+  def do_type_1_run(run_num)
+    ENV['run_number'] = run_num.to_s
+    assert_nothing_raised do
+      run_ctl_file("scd_test_type_1.ctl")
+    end
+  end
+  
+  def lines_for(file)
+    File.readlines(File.dirname(__FILE__) + "/output/#{file}")
+  end
+  
+  def run_ctl_file(file)
+    ETL::Engine.process(File.dirname(__FILE__) + "/#{file}")
+  end
+  
+  def count_bobs
+    @connection.select_value(
+      "SELECT count(*) FROM person_dimension WHERE first_name = 'Bob' and last_name = 'Smith'").to_i
+  end
+  
+  def find_bobs
+    bobs = @connection.select_all(
+      "SELECT * FROM person_dimension WHERE first_name = 'Bob' and last_name = 'Smith'")
+    bobs.each do |bob|
+      def bob.id
+        self["id"].to_i
+      end
+      def bob.effective_date
+        DateTime.parse(self["effective_date"])
+      end
+      def bob.end_date
+        DateTime.parse(self["end_date"])
+      end
+      def bob.latest_version?
+        ActiveRecord::ConnectionAdapters::Column.value_to_boolean(self["latest_version"])
+      end
+    end
+    bobs
+  end
+  
+  def current_datetime
+    DateTime.parse(Time.now.to_s(:db))
+  end
+  
+  def assert_boston_address(bob, street = "200 South Drive")
+    assert_equal street, bob['address'], bob.inspect
+    assert_equal "Boston", bob['city'], bob.inspect
+    assert_equal "MA", bob['state'], bob.inspect
+    assert_equal "32123", bob['zip_code'], bob.inspect
+  end
+  
+  def assert_los_angeles_address(bob, street = "1010 SW 23rd St")
+    assert_equal street, bob['address'], bob.inspect
+    assert_equal "Los Angeles", bob['city'], bob.inspect
+    assert_equal "CA", bob['state'], bob.inspect
+    assert_equal "90392", bob['zip_code'], bob.inspect
+  end
+end