ndr_support 3.1.1

data/test/safe_path_test.rb

@@ -0,0 +1,168 @@
+require 'test_helper'
+
+# Switch on the patientlimiter as though in external environment
+
+class SafePathTest < Minitest::Test
+  def setup
+    @sp = SafePath.new('dbs_outbox').join!('/usr/lib')
+  end
+
+  def test_reconfiguring_exception
+    # We need SafePath to be well-configured for testing already:
+    SafePath.fs_paths # force configuration
+    assert_raises(SecurityError) { SafePath.configure! 'dodgy_config.yml' }
+  end
+
+  test 'path passed to the constructor is always relative to the root of the path space' do
+    assert_equal @sp.to_s, '/mounts/ron/dbs_outbox/usr/lib'
+  end
+
+  test 'permissions are combination of w or r or x' do
+    assert_equal Array, @sp.permissions.class
+    assert_equal %w(r w x), @sp.permissions
+
+    @sp.permissions = 'r'
+    assert_equal ['r'], @sp.permissions
+
+    # The assignment of the permissions preserves the order, although this is not
+    # necessary.
+    @sp.permissions = %w(w r)
+    assert_equal %w(w r), @sp.permissions
+
+    # The class shouldn't keep duplicates and should flattent the arrays
+    @sp.permissions = ['w', 'r', 'x', 'w', 'r', %w(x r)]
+    assert_equal %w(w r x), @sp.permissions
+  end
+
+  test 'safe path raises exception if parmission different from rwx is passed' do
+    @sp.permissions = 'w'
+    assert_raises ArgumentError do
+      @sp.permissions = %w(r w potato)
+    end
+
+    # The class sould keep it's old permissions in case of raised exception
+    assert_equal ['w'], @sp.permissions
+  end
+
+  test 'safe path should remember the pathspace' do
+    assert_equal 'dbs_outbox', @sp.path_space
+  end
+
+  test 'safe path should remember root and return another instance of safe path rather than string' do
+    @sp.permissions = %w(w x)
+    root = @sp.root
+    assert_equal SafePath, @sp.root.class
+    assert_equal '/mounts/ron/dbs_outbox', root.to_s
+
+    assert_equal @sp.permissions, root.permissions
+    assert_equal @sp.path_space, root.path_space
+  end
+
+  test 'safe path should raise exception if unsafe path passed to constructor' do
+    assert_raises SecurityError do
+      SafePath.new('dbs_outbox').join!('../../../evil_path')
+    end
+  end
+
+  test 'safe path should raise expecption if incorrect path is assigned' do
+    assert_raises SecurityError do
+      @sp.path = '/etc/passwd'
+    end
+
+    assert_raises SecurityError do
+      @sp.path = '/mounts/ron/dbs_outbox/../../../evil_path'
+    end
+  end
+
+  test 'join should return SafePath' do
+    assert_equal SafePath, @sp.join('/test').class
+  end
+
+  test 'join sould raise exception if insecure path constructed' do
+    assert_raises SecurityError do
+      @sp.join('../../../evil_path')
+    end
+  end
+
+  test 'join should create new object' do
+    refute_equal @sp.object_id, @sp.join('test').object_id
+  end
+
+  test 'join! should return SafePath' do
+    assert_equal SafePath, @sp.join!('/test').class
+  end
+
+  test 'join! sould raise exception if insecure path constructed' do
+    path = @sp.to_s
+
+    assert_raises SecurityError do
+      @sp.join!('/../../../evil_path')
+    end
+
+    # if join is unsuccessful then it shouldn't alter the path
+    assert_equal path, @sp.to_s
+  end
+
+  test 'join! should work in-place' do
+    assert_equal @sp.object_id, @sp.join!('test').object_id
+  end
+
+  test '+ should return SafePath' do
+    assert_equal SafePath, (@sp + '/test').class
+  end
+
+  test '+ sould raise exception if insecure path constructed' do
+    assert_raises SecurityError do
+      @sp + '../../../evil_path'
+    end
+  end
+
+  test '+ should create new object' do
+    refute_equal @sp.object_id, (@sp + 'test').object_id
+  end
+
+  test "constructor should raise exception if the path space doesn't exist" do
+    assert_raises ArgumentError do
+      SafePath.new('potato_space')
+    end
+  end
+
+  test 'constructor should raise exception if path space is broken' do
+    assert_raises ArgumentError do
+      SafePath.new('broken_space')
+    end
+  end
+
+  test 'should reject root paths that are not subpath of the root specified in the yaml file' do
+    assert_raises SecurityError do
+      SafePath.new('dbs_outbox', '../../evil_path')
+    end
+  end
+
+  test 'should accept root paths that are subpath of the root specified in the yaml file' do
+    assert_equal '/mounts/ron/dbs_outbox/nice_path/path',
+                 SafePath.new('dbs_outbox', 'nice_path/path').root.to_s
+  end
+
+  test 'should restrict the access only to the subpath specified in the contructor rather than the root in the yaml file' do
+    assert_raises SecurityError do
+      SafePath.new('dbs_outbox', 'nice_path/path').join!('../evil_path_under_the_root')
+    end
+
+    assert_raises SecurityError do
+      sp = SafePath.new('dbs_outbox', 'nice_path/path')
+      sp.path = '/mounts/ron/dbs_outbox/evil_path'
+    end
+
+    assert_raises SecurityError do
+      SafePath.new('dbs_outbox', 'nice_path/path').join('../../evil_path')
+    end
+
+    assert_raises SecurityError do
+      SafePath.new('dbs_outbox', 'nice_path/path') + '../../evil_path'
+    end
+  end
+end
+
+# TODO:
+# Alternative .

data/test/string/cleaning_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+
+class String::CleaningTest < Minitest::Test
+  # squash
+
+  test 'postcodeize' do
+    assert_equal 'CB22 3AD', 'CB223AD'.postcodeize
+    assert_equal 'CB2 2QQ', 'CB22QQ'.postcodeize
+    assert_equal 'CB2 2QQ', 'CB22QQ  '.postcodeize
+    assert_equal 'CB2 2QQ', 'C   B   22QQ  '.postcodeize
+    assert_equal 'CB22QQ', 'CB2 2QQ'.postcodeize(:compact)
+    assert_equal 'CB2 2QQ', 'CB22QQ  '.postcodeize(:db)
+    assert_equal 'CB2A2QQ', 'CB2A 2QQ  '.postcodeize(:db)
+    assert_equal '', ''.postcodeize
+    assert_equal 'CB2 2QQ', 'cb22qq'.postcodeize(:db)
+    # Database storage format for all major UK postcode formats:
+    assert_equal 'A9  9AA', 'A9 9AA'.postcodeize(:db)
+    assert_equal 'A99 9AA', 'A99 9AA'.postcodeize(:db)
+    assert_equal 'A9A 9AA', 'A9A 9AA'.postcodeize(:db)
+    assert_equal 'AA9 9AA', 'AA9 9AA'.postcodeize(:db)
+    assert_equal 'AA999AA', 'AA99 9AA'.postcodeize(:db)
+    assert_equal 'AA9A9AA', 'AA9A 9AA'.postcodeize(:db)
+    # Examples of legacy postcodes, that should be unchanged
+    assert_equal 'IP222', 'IP222'.postcodeize(:db)
+    assert_equal 'IP222E', 'IP222E'.postcodeize(:db)
+    assert_equal 'HANTS', 'HANTS'.postcodeize(:db)
+  end
+
+  test 'xml_unsafe?' do
+    without_control = 'hello world!'
+    refute without_control.xml_unsafe?
+
+    with_safe_control = "increase: 100\045"
+    refute with_safe_control.xml_unsafe?
+
+    with_unsafe_control = "Lorem \000Ipsum\000"
+    assert with_unsafe_control.xml_unsafe?
+  end
+
+  test 'strip_xml_unsafe_characters' do
+    without_control = 'hello world!'
+    assert_equal without_control, without_control.strip_xml_unsafe_characters
+
+    with_safe_control = "increase: 100\045"
+    assert_equal 'increase: 100%', with_safe_control.strip_xml_unsafe_characters
+
+    with_unsafe_control = "Lorem \000Ipsum\000"
+    assert_equal 'Lorem Ipsum', with_unsafe_control.strip_xml_unsafe_characters
+  end
+
+  test 'clean xmlsafe' do
+    without_control = 'hello world!'
+    assert_equal without_control, without_control.clean(:xmlsafe)
+
+    with_safe_control = "increase: 100\045"
+    assert_equal 'increase: 100%', with_safe_control.clean(:xmlsafe)
+
+    with_unsafe_control = "Lorem \007Ipsum\006"
+    assert_equal 'Lorem Ipsum', with_unsafe_control.clean(:xmlsafe)
+  end
+
+  test 'clean make_xml_safe' do
+    without_control = 'hello world!'
+    assert_equal without_control, without_control.clean(:make_xml_safe)
+
+    with_safe_control = "increase: 100\045"
+    assert_equal 'increase: 100%', with_safe_control.clean(:make_xml_safe)
+
+    with_unsafe_control = "Lorem \000Ipsum\000"
+    assert_equal 'Lorem Ipsum', with_unsafe_control.clean(:make_xml_safe)
+  end
+
+  test 'clean nhsnumber' do
+    assert_equal '1234567890', '123 456 7890'.clean(:nhsnumber)
+    assert_equal '1234567890', '    123-456-7890123'.clean(:nhsnumber)
+    assert_equal '', 'unknown'.clean(:nhsnumber)
+    assert_equal '', ''.clean(:nhsnumber)
+  end
+
+  test 'clean postcode' do
+    assert_equal 'CB4 3ND', 'cb4   3ND '.clean(:postcode)
+    assert_equal 'CB223AD', ' CB22 3AD'.clean(:postcode)
+    assert_equal '', ''.clean(:postcode)
+  end
+
+  test 'clean lpi' do
+    #   self.upcase.delete('^0-9A-Z')
+    assert_equal '007', '007?!?'.clean(:lpi)
+    assert_equal 'A0000001', 'a0000001'.clean(:lpi)
+    assert_equal 'UNKNOWN', 'UNKNOWN'.clean(:lpi)
+    assert_equal '', ''.clean(:lpi)
+  end
+
+  test 'clean sex' do
+    assert_equal '1', 'male'.clean(:sex)
+    assert_equal '1', '1'.clean(:sex)
+    assert_equal '2', 'F'.clean(:sex)
+    assert_equal '2', '2'.clean(:sex)
+    assert_equal '0', ''.clean(:sex)
+    assert_equal '0', 'unknown'.clean(:sex)
+  end
+
+  test 'clean sex_c' do
+    assert_equal 'M', 'male'.clean(:sex_c)
+    assert_equal 'M', '1'.clean(:sex_c)
+    assert_equal 'F', 'F'.clean(:sex_c)
+    assert_equal 'F', '2'.clean(:sex_c)
+    assert_equal '', ''.clean(:sex_c)
+    assert_equal '', 'unknown'.clean(:sex_c)
+  end
+
+  test 'clean name' do
+    assert_equal 'MAKE A NAME', ' Make A. Name       '.clean(:name)
+    assert_equal 'PUNCTUATE A NAME', 'PUNCTUATE,A;NAME'.clean(:name)
+    assert_equal 'SPREAD A NAME', 'spread    a      name'.clean(:name)
+    assert_equal "O'NAME", 'O`NAME'.clean(:name)
+    assert_equal "JOHN MIDDLE O'NAME", 'John,  Middle.   O`NAME'.clean(:name)
+    assert_equal '', ''.clean(:name)
+  end
+
+  test 'clean ethniccategory' do
+    assert_equal 'M', '1'.clean(:ethniccategory)
+    assert_equal 'X', '99'.clean(:ethniccategory)
+    assert_equal 'A', 'A'.clean(:ethniccategory)
+    assert_equal 'INVALID', 'InValid'.clean(:ethniccategory)
+    assert_equal '', ''.clean(:ethniccategory)
+  end
+
+  test 'clean code' do
+    assert_equal 'a123 B456', ' a12.3,,B45.6;'.clean(:code)
+    assert_equal 'A123 B456', 'A12.3 B.456'.clean(:code)
+    assert_equal 'UNKNOWN', 'UNKNOWN'.clean(:code)
+    assert_equal '', ''.clean(:code)
+  end
+
+  test 'clean code_icd' do
+    # TODO
+  end
+
+  test 'clean code_opcs' do
+    assert_equal 'B274 Z943', ' b27.4,Z94.3;'.clean(:code_opcs)
+    assert_equal 'B274 Z943', 'B27.4 Z94.3'.clean(:code_opcs)
+    assert_equal 'CZ001', 'CZ001'.clean(:code_opcs)
+    assert_equal 'B274 CZ002', 'B27.4 cz00.2'.clean(:code_opcs)
+    assert_equal '', 'CZ003'.clean(:code_opcs)
+    assert_equal '', 'UNKNOWN'.clean(:code_opcs)
+    assert_equal '', ''.clean(:code_opcs)
+  end
+
+  test 'clean hospitalnumber' do
+    assert_equal 'a0000001', 'a0000001'.clean(:hospitalnumber)
+    assert_equal 'A0000001', 'A0000001B'.clean(:hospitalnumber)
+    assert_equal 'UNKNOW', 'UNKNOWN'.clean(:hospitalnumber)
+    assert_equal '', ''.clean(:hospitalnumber)
+  end
+
+  test 'clean tnmcategory' do
+    assert_equal '', ''.clean(:tnmcategory)
+    assert_equal 'X', 'X'.clean(:tnmcategory)
+    assert_equal 'X', 'x'.clean(:tnmcategory)
+    assert_equal '1a', '1A'.clean(:tnmcategory)
+    assert_equal '1a', '1a'.clean(:tnmcategory)
+    assert_equal '1a', 'T1A'.clean(:tnmcategory)
+    assert_equal '1a', 't1a'.clean(:tnmcategory)
+    assert_equal 'X', 'TX'.clean(:tnmcategory)
+    assert_equal 'X', 'tx'.clean(:tnmcategory)
+    assert_equal 'X', 'Tx'.clean(:tnmcategory)
+    assert_equal 'X', 'tX'.clean(:tnmcategory)
+  end
+
+  test 'clean fallback' do
+    assert_equal 'UN KNOWN', 'UN ?KNOWN'.clean(:somethingorother)
+    assert_equal 'UNKNOWN', 'UNKNOWN'.clean(:somethingorother)
+    assert_equal '', ''.clean(:somethingorother)
+  end
+end

data/test/string/conversions_test.rb

@@ -0,0 +1,353 @@
+require 'test_helper'
+
+class String::ConversionsTest < Minitest::Test
+  test 'soundex' do
+    assert_equal 'C460', 'colour'.soundex
+    assert_equal 'color'.soundex, 'colour'.soundex
+    assert 'color'.sounds_like('colour')
+  end
+
+  test 'date1' do
+    assert_equal '01.01.2000', '2000'.date1.to_s
+  end
+
+  test 'date2' do
+    assert_equal '31.12.2000', '2000'.date2.to_s
+  end
+
+  test 'thedate' do
+    # Treating a String like Ourdate
+    d = '01.03.2000'.thedate
+    assert_kind_of Date, d
+    assert_equal '01.03.2000', d.to_s
+
+    assert_equal '03.04.2000', '03042000'.thedate.to_s
+    assert_nil '01!02'.thedate, 'Expected illegal date format'
+    assert_nil '2000'.thedate, 'Date ranges are illegal as single dates'
+  end
+
+  test 'thetime' do
+    # Treating a local-format String like Ourtime (without seconds)
+    t = '01.02.1993 04:05'.thetime
+    assert_kind_of Time, t
+    assert_equal '1993-02-01 04:05:00', t.strftime('%Y-%m-%d %H:%M:%S')
+  end
+
+  test 'surname_and_initials' do
+    assert_equal 'Smith JD', 'SMITH JD'.surname_and_initials
+    assert_equal 'Pencheon JM', 'PENCHEON JM'.surname_and_initials
+  end
+
+  test 'surnameize' do
+    assert_equal 'Smith', 'SMITH'.surnameize
+    assert_equal 'McKinnon', 'MCKINNON'.surnameize
+    assert_equal 'O\'Neil', 'o\'neil'.surnameize
+    assert_equal 'X', 'X'.surnameize
+    assert_equal '', ''.surnameize
+  end
+
+  test 'nhs_numberize' do
+    assert_equal '123 456 7890', '1234567890'.nhs_numberize
+    assert_equal '012 345 6789', '0123456789'.nhs_numberize
+    assert_equal '012345678', '012345678'.nhs_numberize
+    assert_equal '', ''.nhs_numberize
+  end
+
+  test 'should parse dates correctly' do
+    assert_ymd [2001, 3, 2],  '02.03.2001'.to_date
+    assert_ymd [2001, 3, 2],  '02/03/2001'.to_date
+    assert_ymd [2010, 7, 11], '2010-07-11'.to_date
+
+    assert_ymd [2001, 2, 3], '2001/02/03'.to_date('yyyy/mm/dd')
+    assert_ymd [2001, 2, 3], '2001/03/02'.to_date('yyyy/dd/mm')
+    assert_ymd [2001, 2, 3], '2001-02-03'.to_date('yyyy-mm-dd')
+    assert_ymd [2001, 2, 3], '03/02/2001'.to_date('dd/mm/yyyy')
+    assert_ymd [2001, 2, 3], '02/03/2001'.to_date('mm/dd/yyyy')
+
+    assert_ymd [2001, 2, 3],  '03-02-2001'.to_date('dd-mm-yyyy')
+    assert_ymd [1976, 9, 23], '23-09-1976'.to_date('dd-mm-yyyy')
+
+    assert_ymd [2001, 2, 3], '20010203'.to_date
+
+    assert_ymd [1954, 2, 3], '03/02/54'.to_date
+    assert_ymd [2014, 2, 3], '03/02/14'.to_date
+    assert_ymd [2014, 2, 3], '03/FEB/14'.to_date
+
+    assert_ymd [2014, 2, 3], '03-02-2014 00:00:00'.to_date
+    assert_ymd [2014, 2, 3], '2014-02-03 00:00:00'.to_date
+    assert_ymd [2014, 3, 2], '2014/03/02 13:02:01'.to_date
+  end
+
+  test 'ParseDate should behave consistently' do
+    # We use ParseDate (and thus Date._parse) for
+    # converting strings to dates. Its behaviour
+    # has been known to change...
+    #
+    # Using '.' as a separator rather than '/' appears
+    # to be more reliable across Ruby versions, and
+    # as that is what we use internally, that is all
+    # that we need to test here:
+
+    # Behaves as you might hope:
+    assert_ymd_parsed [2001, 2, 3], ParseDate.parsedate('20010203')
+    assert_ymd_parsed [2001, 2, 3], ParseDate.parsedate('03.02.2001')
+
+    # Doesn't behave as you might hope, but reliably gets day and year mixed:
+    assert_ymd_parsed [3, 2, 14], ParseDate.parsedate('03.02.14')
+    assert_ymd_parsed [3, 2, 54], ParseDate.parsedate('03.02.54')
+    assert_ymd_parsed [3, 11, 4], ParseDate.parsedate('03.11.04')
+
+    # Doesn't behave as you might hope, but reliably gets month and year mixed:
+    assert_ymd_parsed [14, 2, 3], ParseDate.parsedate('03.FEB.14')
+    assert_ymd_parsed [54, 2, 3], ParseDate.parsedate('03.FEB.54')
+    assert_ymd_parsed [4, 2, 3],  ParseDate.parsedate('03.FEB.04')
+  end
+
+  test 'should calculate date differences / ages correctly' do
+    [['03.02.1976', '11.11.2011', 35],
+     ['29.02.1976', '28.02.2011', 35],
+     ['28.02.1976', '28.02.2011', 35],
+     ['28.02.1976', '27.02.2011', 34],
+     ['01.03.1976', '28.02.2011', 34]
+    ].each do |date1, date2, expected_diff|
+      date1 = date1.to_date if date1.is_a?(String)
+      date2 = date2.to_date if date2.is_a?(String)
+      assert_equal(expected_diff,
+                   Ourdate.date_difference_in_years(date2, date1),
+                   "Expected difference between #{date2} and #{date1} to be #{expected_diff} years"
+                   )
+    end
+  end
+
+  # to_date(pattern = nil)
+  test 'dd/mm/yyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/02/1945'.to_date('dd/mm/yyyy')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03/05/1945'.to_date('dd/mm/yyyy')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13/02/1998'.to_date('dd/mm/yyyy')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03/05/1998'.to_date('dd/mm/yyyy')
+
+    # reverse pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/02/1945'.to_date('yyyy/mm/dd')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03/05/1945'.to_date('yyyy/mm/dd')
+    # reverse post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13/02/1998'.to_date('yyyy/mm/dd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03/05/1998'.to_date('yyyy/mm/dd')
+  end
+
+  test 'yyyy/mm/dd string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945/02/13'.to_date('yyyy/mm/dd')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945/05/03'.to_date('yyyy/mm/dd')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998/02/13'.to_date('yyyy/mm/dd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998/05/03'.to_date('yyyy/mm/dd')
+
+    # reverse pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945/02/13'.to_date('dd/mm/yyyy')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945/05/03'.to_date('dd/mm/yyyy')
+    # reverse post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998/02/13'.to_date('dd/mm/yyyy')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998/05/03'.to_date('dd/mm/yyyy')
+  end
+
+  test 'yyyymmdd string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '19450213'.to_date('yyyymmdd')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '19450503'.to_date('yyyymmdd')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '19980213'.to_date('yyyymmdd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '19980503'.to_date('yyyymmdd')
+
+    # long pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '19450213SOMETHING'.to_date('yyyymmdd')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '19450503SOMETHING'.to_date('yyyymmdd')
+    # long post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '19980213SOMETHING'.to_date('yyyymmdd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '19980503SOMETHING'.to_date('yyyymmdd')
+
+    # ONS wildcard date formats
+    # (cannot convert to a Date, but need to parse into EBaseRecord date fields)
+    assert_equal nil, '19450000'.to_date('yyyymmdd')
+    assert_equal nil, '19450300'.to_date('yyyymmdd')
+    assert_equal nil, '19450013'.to_date('yyyymmdd')
+
+    # parse our own date format correctly, regardless of format specification
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13.02.1998'.to_date('yyyymmdd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03.05.1998'.to_date('yyyymmdd')
+  end
+
+  test 'ddmmyyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13021945'.to_date('ddmmyyyy')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03051945'.to_date('ddmmyyyy')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13021998'.to_date('ddmmyyyy')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03051998'.to_date('ddmmyyyy')
+
+    # long pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13021945SOMETHING'.to_date('ddmmyyyy')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03051945SOMETHING'.to_date('ddmmyyyy')
+    # long post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13021998SOMETHING'.to_date('ddmmyyyy')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03051998SOMETHING'.to_date('ddmmyyyy')
+  end
+
+  test 'mm/dd/yyyy string to_date' do
+    # This is currently unsupported, but will be tested if implemented
+    begin
+      # pre_epoch
+      assert_equal Ourdate.build_datetime(1945, 02, 13), '02/13/1945'.to_date('mm/dd/yyyy')
+      assert_equal Ourdate.build_datetime(1945, 05, 03), '05/03/1945'.to_date('mm/dd/yyyy')
+      # post epoch
+      assert_equal Ourdate.build_datetime(1998, 02, 13), '02/13/1998'.to_date('mm/dd/yyyy')
+      assert_equal Ourdate.build_datetime(1998, 05, 03), '05/03/1998'.to_date('mm/dd/yyyy')
+    rescue RuntimeError => e
+      raise e unless e.message == 'Unsupported date format'
+    end
+  end
+
+  test 'yyyy-mm-dd string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945-02-13'.to_date('yyyy-mm-dd')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945-05-03'.to_date('yyyy-mm-dd')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998-02-13'.to_date('yyyy-mm-dd')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998-05-03'.to_date('yyyy-mm-dd')
+  end
+
+  test 'dd-mm-yyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13-02-1945'.to_date('dd-mm-yyyy')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03-05-1945'.to_date('dd-mm-yyyy')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13-02-1998'.to_date('dd-mm-yyyy')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03-05-1998'.to_date('dd-mm-yyyy')
+  end
+
+  test '%Y-%m-%d string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945-02-13'.to_date('%Y-%m-%d')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945-05-03'.to_date('%Y-%m-%d')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998-02-13'.to_date('%Y-%m-%d')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998-05-03'.to_date('%Y-%m-%d')
+
+    assert ''.to_date('%Y-%m-%d').blank?
+    assert '  '.to_date('%Y-%m-%d').blank?
+  end
+
+  test '%d-%m-%Y string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13-02-1945'.to_date('%d-%m-%Y')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03-05-1945'.to_date('%d-%m-%Y')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13-02-1998'.to_date('%d-%m-%Y')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03-05-1998'.to_date('%d-%m-%Y')
+  end
+
+  test '%Y %b %d string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945 Feb 13'.to_date('%Y %b %d')
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945 May 03'.to_date('%Y %b %d')
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998 Feb 13'.to_date('%Y %b %d')
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998 May 03'.to_date('%Y %b %d')
+  end
+
+  test 'inferred yyyy-mm-dd string to_date' do
+    # pattern pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '1945-02-13'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '1945-05-03 00:00:00'.to_date
+    # pattern post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '1998-02-13 00:00:00'.to_date
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '1998-05-03'.to_date
+  end
+
+  test 'inferred dd-mm-yyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13-02-1945'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03-05-1945 00:00:00'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13-02-1998 00:00:00'.to_date
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03-05-1998'.to_date
+  end
+
+  test 'inferred dd.mm.yyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13.02.1945'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '3.5.1945'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(1998, 02, 13), '13.2.1998'.to_date
+    assert_equal Ourdate.build_datetime(1998, 05, 03), '03.05.1998'.to_date
+  end
+
+  test 'inferred yyyymmdd string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '19450213'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '19450503'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(2008, 02, 13), '20080213'.to_date
+    assert_equal Ourdate.build_datetime(2008, 05, 03), '20080503'.to_date
+  end
+
+  test 'inferred dd/mm/yy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/02/45'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03/05/45'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(2008, 02, 13), '13/02/08'.to_date
+    assert_equal Ourdate.build_datetime(2008, 05, 03), '03/05/08'.to_date
+  end
+
+  test 'inferred dd/mmm/yy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/FEB/45'.to_date
+    assert_equal Ourdate.build_datetime(1945, 06, 03), '03/JUN/45'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(2008, 02, 13), '13/FEB/08'.to_date
+    assert_equal Ourdate.build_datetime(2008, 06, 03), '03/JUN/08'.to_date
+  end
+
+  test 'inferred dd/mm/yyyy string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/02/1945'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03/05/1945'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(2008, 02, 13), '13/02/2008'.to_date
+    assert_equal Ourdate.build_datetime(2008, 05, 03), '03/05/2008'.to_date
+  end
+
+  test 'inferred dd/mm/yyyy hh:mm string to_date' do
+    # pre_epoch
+    assert_equal Ourdate.build_datetime(1945, 02, 13), '13/02/1945 13:38'.to_date
+    assert_equal Ourdate.build_datetime(1945, 05, 03), '03/05/1945 13:38'.to_date
+    # post epoch
+    assert_equal Ourdate.build_datetime(2008, 02, 13), '13/02/2008 13:38'.to_date
+    assert_equal Ourdate.build_datetime(2008, 05, 03), '03/05/2008 13:38'.to_date
+  end
+
+  test 'to_boolean' do
+    assert_equal true, 'true'.to_boolean
+    assert_equal true, 'yes'.to_boolean
+    assert_equal true, '1'.to_boolean
+    assert_equal false, 'false'.to_boolean
+    assert_equal false, 'no'.to_boolean
+    assert_equal false, '0'.to_boolean
+    assert_raises ArgumentError do
+      'meaningless'.to_boolean
+    end
+  end
+
+  def assert_ymd(ymd, date)
+    assert_equal ymd.first,  date.year,  'years were not equal'
+    assert_equal ymd.second, date.month, 'months were not equal'
+    assert_equal ymd.third,  date.day,   'days were not equal'
+  end
+
+  def assert_ymd_parsed(ymd, parse_results)
+    y, m, d, *_ = parse_results
+    assert_equal ymd, [y, m, d]
+  end
+end