ndr_support 5.10.4 → 5.10.5

data/test/safe_path_test.rb

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

@@ -1,247 +0,0 @@
-require 'test_helper'
-
-class String
-  class CleaningTest < Minitest::Test
-    # squash
-
-    test 'postcodeize' do
-      assert_equal 'CB22 3AD', 'CB223AD'.postcodeize
-      assert_equal 'NOTCB223AD', 'NOTCB223AD'.postcodeize
-      assert_equal 'CB2 2QQ', 'CB22QQ'.postcodeize
-      assert_equal 'CB2 2QQ', 'CB22QQ  '.postcodeize
-      assert_equal 'CB2 2QQ', 'C   B   22QQ  '.postcodeize
-      assert_equal 'CB2 2QQ', "CB2\u00a02QQ".postcodeize # Unicode non-breaking space
-      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)
-      # Old Newport postcodes until end 1984
-      assert_equal 'NPT 1AA' , 'NPT  1AA'.postcodeize(:db)
-      assert_equal 'NPT 1AA' , 'NPT 1AA'.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 'clean_log10' do
-      assert_equal '0.0', '0'.clean(:log10)
-      assert_equal '-10.1', '-10.1'.clean(:log10)
-      assert_match(/\A0.041392685158225[0-9]*\z/, '1.1'.clean(:log10),
-                   "Different ruby versions give '0.04139268515822507' or '0.04139268515822508'")
-      assert_equal 'BILBO', 'BILBO'.clean(:log10)
-    end
-
-    test 'clean_roman5' do
-      assert_equal '12345', 'I2345'.clean(:roman5)
-      assert_equal '12345', '1II345'.clean(:roman5)
-      assert_equal '12345', '12III45'.clean(:roman5)
-      assert_equal '12345', '123IIII5'.clean(:roman5)
-      assert_equal '12345', '123IIII5'.clean(:roman5)
-      assert_equal '12345', '123IV5'.clean(:roman5)
-      assert_equal '12345', '1234V'.clean(:roman5)
-      assert_equal '12345', '1II34V'.clean(:roman5)
-    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 gender' do
-      assert_equal '1', 'M'.clean(:gender)
-      assert_equal '1', 'male'.clean(:gender)
-      assert_equal '1', '1'.clean(:gender)
-      assert_equal '2', 'F'.clean(:gender)
-      assert_equal '2', 'Female'.clean(:gender)
-      assert_equal '2', '2'.clean(:gender)
-      assert_equal '4000', '4000'.clean(:gender)
-      assert_equal '9', '9'.clean(:gender)
-      assert_equal 'UNK', 'UNK'.clean(:gender)
-      assert_equal '', ''.clean(:gender)
-    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
-      assert_equal 'C449 Q123A Q455', 'C449,Q123,A,Q455'.clean(:code_icd)
-      assert_equal 'C449 Q123D Q455', 'C449,Q123,D,Q455'.clean(:code_icd)
-    end
-
-    test 'clean icd' do
-      assert_equal 'C509', '  c50.9; '.clean(:icd)
-      assert_equal 'C50 C509', ' C50X, c50.9; '.clean(:icd)
-      assert_equal 'D04', 'd04'.clean(:icd)
-      assert_equal 'C32', ';C32.X'.clean(:icd)
-      assert_equal 'C32', ';C32X'.clean(:icd)
-      assert_equal 'X32 X901A', ';X32.X;x90.1.a'.clean(:icd)
-    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 upcase' do
-      assert_equal '', ''.clean(:upcase)
-      assert_equal 'DOWNCASE', 'downcase'.clean(:upcase)
-      assert_equal 'MIXEDCASE', 'mIxEdCaSe'.clean(:upcase)
-      assert_equal 'UPCASE', 'UPCASE'.clean(:upcase)
-    end
-
-    test 'clean strip' do
-      assert_equal '', ''.clean(:strip)
-      assert_equal 'no leading or trailing spaces', 'no leading or trailing spaces'.clean(:strip)
-      assert_equal 'leading and trailing spaces', '  leading and trailing spaces  '.clean(:strip)
-      assert_equal 'leading spaces', '    leading spaces'.clean(:strip)
-      assert_equal 'trailing spaces', 'trailing spaces  '.clean(:strip)
-    end
-
-    test 'clean itself' do
-      assert_equal '  leading & trailing spaces  ', '  leading & trailing spaces  '.clean(:itself)
-      assert_equal 'no leading or trailing spaces', 'no leading or trailing spaces'.clean(:itself)
-      assert_equal '      ', '      '.clean(:itself)
-      assert_equal '', ''.clean(:itself)
-    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
-end