ndr_support 3.1.1

data/test/integer_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+# This tests our Integer extension
+class IntegerTest < Minitest::Test
+  def test_rounding
+    assert_equal 124_000, 123_221.round_up_to(3)
+    assert_equal 123_300, 123_221.round_up_to(4)
+    assert_equal 760, 758.round_up_to(2)
+    assert_equal 3453, 3452.round_up_to(4)
+    assert_nil 1.round_up_to(2)
+    refute_nil 10.round_up_to(2)
+    assert_nil 12.round_up_to(-45)
+  end
+end

data/test/nil_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+# This tests our Nil extension
+class NilTest < Minitest::Test
+  test 'to_date' do
+    assert_nil nil.to_date
+  end
+
+  test 'titleize' do
+    assert_nil nil.titleize
+  end
+
+  test 'surnameize' do
+    assert_nil nil.surnameize
+  end
+
+  test 'postcodeize' do
+    assert_nil nil.postcodeize
+  end
+
+  test 'upcase' do
+    assert_nil nil.upcase
+  end
+
+  test 'clean' do
+    assert_nil nil.clean(:tnmcategory)
+  end
+
+  test 'squash' do
+    assert_nil nil.squash
+  end
+
+  test 'gsub' do
+    assert_equal '', nil.gsub(/.*/)
+  end
+
+  test 'strip' do
+    assert_nil nil.strip
+  end
+end

data/test/ourdate_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+# This tests our Ourdate class
+class OurdateTest < Minitest::Test
+  def test_date_and_time
+    d = Ourdate.build_datetime(2003, 11, 30)
+    assert_equal '30 November 2003', d.to_verbose
+    assert_equal '2003-11-30', d.to_iso
+    assert_equal '30.11.2003', d.to_ours
+    assert_equal '30.11.2003', d.to_s
+  end
+
+  def test_ourdate
+    # Creating an Ourdate from a String
+    od = Ourdate.new('01.02.2000')
+    assert_equal Date.new(2000, 2, 1).to_s(:ui), od.to_s
+    assert_kind_of Date, od.thedate
+    assert_equal '01.02.2000', od.thedate.to_s
+    # Creating an Ourdate from a Date
+    od = Ourdate.new(Date.new(2000, 3, 1))
+    assert_equal '01.03.2000', od.to_s
+  end
+
+  def test_blank
+    assert Ourdate.new.blank?  # delegates to empty?
+  end
+end

data/test/ourtime_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+# This tests our Ourtime class
+class OurtimeTest < Minitest::Test
+  def test_initialize_with_local_format_string
+    # Creating an Ourtime from a local-format String (with seconds)
+    ot = Ourtime.new('01.02.1993 04:05:06')
+    assert_equal '1993-02-01 04:05:06', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
+    assert_kind_of Time, ot.thetime
+  end
+
+  def test_initialize_with_time
+    # Creating an Ourtime from a Time
+    ot = Ourtime.new(Time.mktime(1993, 2, 1, 4, 5))
+    assert_equal '01.02.1993 04:05', ot.to_s
+  end
+
+  def test_initialize_with_no_parameters
+    assert Ourtime.new.blank?  # delegates to empty?
+  end
+
+  def test_initialize_with_iso_string
+    # Parsing an ISO datetime
+    ot = Ourtime.new('1993-04-05 06:07:08')
+    assert_equal '1993-04-05 06:07:08', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
+  end
+end

data/test/regexp_range_test.rb

@@ -0,0 +1,135 @@
+require 'test_helper'
+
+# This tests our RegexpRange class
+class RegexpRangeTest < Minitest::Test
+  def setup
+    @lines = [
+      '0Lorem ipsum dolor sit amet',
+      '1consectetur adipisicing elit',
+      '2sed do eiusmod tempor incididunt ut labore et dolore magna aliqua',
+      '3Ut enim ad minim veniam, quis nostrud exercitation ullamco',
+      '4laboris nisi ut aliquip ex ea commodo consequat'
+    ]
+  end
+
+  test 'to_yaml' do
+    regexp_range = RegexpRange.new(0, /^3Ut/)
+
+    # Don't test YAML serialisation directly, but make it can be loaded:
+    deserialized_regexp_range = YAML.load(regexp_range.to_yaml)
+    assert_instance_of RegexpRange, deserialized_regexp_range
+    assert_equal regexp_range.begin, deserialized_regexp_range.begin
+    assert_equal regexp_range.end, deserialized_regexp_range.end
+    assert_equal regexp_range.excl, deserialized_regexp_range.excl
+  end
+
+  test 'to_range with number and number' do
+    assert_equal Range.new(2, 3, true), RegexpRange.new(2, 3, true).to_range(@lines)
+    assert_equal Range.new(2, 3, false), RegexpRange.new(2, 3, false).to_range(@lines)
+    assert_equal Range.new(0, -1, true), RegexpRange.new(0, -1, true).to_range(@lines)
+    assert_equal Range.new(0, -1, false), RegexpRange.new(0, -1, false).to_range(@lines)
+
+    assert_equal @lines[Range.new(2, 3, true)],
+                 @lines[RegexpRange.new(2, 3, true).to_range(@lines)]
+    assert_equal @lines[Range.new(2, 3, false)],
+                 @lines[RegexpRange.new(2, 3, false).to_range(@lines)]
+  end
+
+  test 'to_range with number and regexp' do
+    assert_equal Range.new(2, 3, true), RegexpRange.new(2, /^3Ut/, true).to_range(@lines)
+    assert_equal Range.new(2, 3, false), RegexpRange.new(2, /^3Ut/, false).to_range(@lines)
+
+    assert_equal @lines[Range.new(2, 3, true)],
+                 @lines[RegexpRange.new(2, /^3Ut/, true).to_range(@lines)]
+    assert_equal @lines[Range.new(2, 3, false)],
+                 @lines[RegexpRange.new(2, /^3Ut/, false).to_range(@lines)]
+
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(2, /^NO_MATCH$/, true).to_range(@lines)
+    end
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(2, /^NO_MATCH$/, false).to_range(@lines)
+    end
+  end
+
+  test 'to_range with regexp and number' do
+    assert_equal Range.new(1, -1, true), RegexpRange.new(/^1consec/, -1, true).to_range(@lines)
+    assert_equal Range.new(1, -1, false), RegexpRange.new(/^1consec/, -1, false).to_range(@lines)
+    assert_equal Range.new(1, 5, true), RegexpRange.new(/^1consec/, 5, true).to_range(@lines)
+    assert_equal Range.new(1, 5, false), RegexpRange.new(/^1consec/, 5, false).to_range(@lines)
+
+    assert_equal @lines[Range.new(1, -1, true)],
+                 @lines[RegexpRange.new(/^1consec/, -1, true).to_range(@lines)]
+    assert_equal @lines[Range.new(1, -1, false)],
+                 @lines[RegexpRange.new(/^1consec/, -1, false).to_range(@lines)]
+
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(/^NO_MATCH$/, 5, true).to_range(@lines)
+    end
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(/^NO_MATCH$/, 5, false).to_range(@lines)
+    end
+  end
+
+  test 'to_range with regexp and regexp' do
+    assert_equal Range.new(1, 3, true),
+                 RegexpRange.new(/^1consec/, /^3Ut/, true).to_range(@lines)
+    assert_equal Range.new(1, 3, false),
+                 RegexpRange.new(/^1consec/, /^3Ut/, false).to_range(@lines)
+
+    assert_equal @lines[Range.new(1, 3, true)],
+                 @lines[RegexpRange.new(/^1consec/, /^3Ut/, true).to_range(@lines)]
+    assert_equal @lines[Range.new(1, 3, false)],
+                 @lines[RegexpRange.new(/^1consec/, /^3Ut/, false).to_range(@lines)]
+
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(/^NO_MATCH$/, /^NO_MATCH$/, true).to_range(@lines)
+    end
+    assert_raises RegexpRange::PatternMatchError do
+      RegexpRange.new(/^NO_MATCH$/, /^NO_MATCH$/, false).to_range(@lines)
+    end
+  end
+
+  test 'comparison to self' do
+    rr1 = RegexpRange.new(/start/, /end/, false)
+    assert_equal rr1, rr1
+  end
+
+  test 'comparison to identical regexprange' do
+    rr1 = RegexpRange.new(/start/, /end/, false)
+    rr2 = RegexpRange.new(/start/, /end/, false)
+    assert_equal rr1, rr2
+  end
+
+  test 'comparison to different regexprange' do
+    rr1 = RegexpRange.new(/start/, /end/, false)
+    rr2 = RegexpRange.new(/start/, /end/, true)
+    refute_equal rr1, rr2
+
+    rr3 = RegexpRange.new(/start/, /end/, false)
+    rr4 = RegexpRange.new(/start/, /finish/, false)
+    refute_equal rr3, rr4
+
+    rr5 = RegexpRange.new(/start/, /end/, true)
+    rr6 = RegexpRange.new(/begin/, /end/, true)
+    refute_equal rr5, rr6
+  end
+
+  test 'hash key comparison' do
+    rr1 = RegexpRange.new(/start/, /end/, false)
+    rr2 = RegexpRange.new(/start/, /end/, false)
+    rr3 = RegexpRange.new(/start/, /end/, true)
+
+    hash = Hash.new { |h, k| h[k] = 0 }
+
+    hash[rr1] += 1
+    hash[rr2] += 1
+    hash[rr3] += 1
+
+    assert_equal 2, hash.keys.length
+
+    assert_equal 2, hash[rr1]
+    assert_equal 2, hash[rr2]
+    assert_equal 1, hash[rr3]
+  end
+end

data/test/resources/filesystem_paths.yml

@@ -0,0 +1,37 @@
+# This allows us different filesystem paths for different platforms
+--- 
+test_files: &test_files
+  root: <%= Dir.mktmpdir %>
+
+? !ruby/regexp /.*/
+: 
+  dbs_outbox: 
+    root: "/mounts/ron/dbs_outbox"
+    prms:
+      - r
+      - w
+      - x
+  broken_space:
+    root: "potato"
+    prms:
+      - r
+      - w
+      - x
+  test_space_r:
+    <<: *test_files
+    prms:
+      - r
+  test_space_w:
+    <<: *test_files
+    prms:
+      - w
+  test_space_rw:
+    <<: *test_files
+    prms:
+      - r
+      - w
+  permanent_test_files:
+    root: <%#= Rails.root.join("test","unit","files") %>
+    prms:
+      - r
+      - w

data/test/safe_file_test.rb

@@ -0,0 +1,597 @@
+require 'test_helper'
+
+# Switch on the patientlimiter as though in external environment
+
+class SafeFileTest < Minitest::Test
+  def setup
+    @not_empty_fpath = SafePath.new('test_space_rw').join('test_file_rw_not_empty')
+
+    File.open(@not_empty_fpath, 'w') do |f|
+      f.write 'I am not empty'
+    end
+
+    @empty_fpath = SafePath.new('test_space_rw').join('test_file_rw')
+
+    File.open(@empty_fpath, 'w') do |f|
+      f.write ''
+    end
+  end
+
+  def teardown
+    FileUtils.rm(Dir[SafePath.new('test_space_rw').join('*')])
+  end
+
+  ################################################################################
+  # .new
+
+  test 'constructor should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.new('example_file', 'rw')
+    end
+  end
+
+  test 'should raise exception if try to write in read-only space' do
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_r').join!('test_file_r'), 'a+')
+    end
+
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_r').join!('test_file_r'), 'a')
+    end
+
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_r').join!('test_file_r'), 'r+')
+    end
+
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_r').join!('test_file_r'), 'w')
+    end
+  end
+
+  test 'should raise exception if try to read in write only space' do
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_w').join!('test_file_w'), 'a+')
+    end
+
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_w').join!('test_file_w'), 'r+')
+    end
+
+    assert_raises SecurityError do
+      SafeFile.new(SafePath.new('test_space_w').join!('test_file_w'), 'r')
+    end
+  end
+
+  test 'should read from read-only space and write to write only space' do
+    write_only_path = SafePath.new('test_space_w').join!('new_file_rw_new_file')
+    read_only_path = SafePath.new('test_space_r').join!('new_file_rw_new_file')
+    refute File.exist?(read_only_path)
+
+    f = SafeFile.new(write_only_path, 'w')
+    assert_equal 4, f.write('test')
+    f.close
+
+    assert File.exist?(read_only_path)
+
+    f = SafeFile.new(read_only_path, 'r')
+    assert_equal 'test', f.read
+    f.close
+  end
+
+  test 'should read/write from file with new to rw space' do
+    fpath = SafePath.new('test_space_rw').join!('new_file_rw_new_file')
+
+    refute File.exist?(fpath)
+
+    f = SafeFile.new(fpath, 'w')
+    assert_equal 4, f.write('test')
+    f.close
+
+    assert File.exist?(fpath)
+
+    f = SafeFile.new(fpath, 'r')
+    assert_equal 'test', f.read
+    f.close
+  end
+
+  test 'should accept mode types' do
+    s = SafeFile.new(@empty_fpath, 'r')
+    s.close
+
+    s = SafeFile.new(@empty_fpath, 'w')
+    s.close
+
+    s = SafeFile.new(@empty_fpath, 'r+')
+    s.close
+
+    s = SafeFile.new(@empty_fpath, 'w+')
+    s.close
+
+    s = SafeFile.new(@empty_fpath, 'a+')
+    s.close
+
+    s = SafeFile.new(@empty_fpath, 'a')
+    s.close
+  end
+
+  test 'should raise exception if incorect mode passed' do
+    assert_raises ArgumentError do
+      SafeFile.new(@empty_fpath, 'potato_mode')
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.new(@empty_fpath, 'rw+a+')
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.new(@empty_fpath, 'r+w+')
+    end
+  end
+
+  test 'should accept permissions' do
+    f = SafeFile.new(@empty_fpath, 'r', 755)
+    f.close
+
+    SafeFile.new(@empty_fpath, 755)
+  end
+
+  ################################################################################
+  # ::open
+
+  test '::open should accept safe_path only' do
+    p = SafePath.new('test_space_rw').join('test1')
+
+    refute File.exist?(p)
+
+    assert_raises ArgumentError do
+      SafeFile.open(p.to_s, 'r') do |f|
+        f.write 'hohohoho'
+      end
+    end
+
+    assert_raises ArgumentError do
+      f = SafeFile.open(p.to_s, 'r')
+      f.write 'hohohoho'
+      f.close
+    end
+
+    refute File.exist?(p)
+  end
+
+  test '::open should check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join!('new_file_rw_blablabla')
+    write_only_path = SafePath.new('test_space_w').join!('test_file_rw_not_empty')
+
+    refute File.exist?(read_only_path)
+
+    assert_raises SecurityError do
+      SafeFile.open(read_only_path, 'w') do |f|
+        f.write('test')
+      end
+    end
+
+    refute File.exist?(read_only_path)
+
+    fcontent = 'something else'
+
+    assert_raises SecurityError do
+      SafeFile.open(write_only_path, 'r') do |f|
+        fcontent = f.read
+      end
+    end
+
+    refute_equal fcontent, File.read(write_only_path)
+  end
+
+  test '::open should read/write from file' do
+    fpath = SafePath.new('test_space_rw').join!('new_file_rw_blablabla')
+    read_only_path = SafePath.new('test_space_r').join!('new_file_rw_blablabla')
+    write_only_path = SafePath.new('test_space_w').join!('new_file_rw_blablabla')
+    refute File.exist?(fpath)
+
+    SafeFile.open(fpath, 'w') do |f|
+      assert_equal 4, f.write('test')
+    end
+
+    SafeFile.open(fpath, 'r') do |f|
+      assert_equal 'test', f.read
+    end
+
+    # Test how the defailt arguments work
+    SafeFile.open(read_only_path) do |f|
+      assert_equal 'test', f.read
+    end
+
+    # Test how the defailt arguments work
+    assert_raises SecurityError do
+      SafeFile.open(write_only_path) do |f|
+        assert_equal 'test', f.read
+      end
+    end
+
+    assert_equal 1, File.delete(fpath)
+  end
+
+  test '::open should accept fs permissions with block' do
+    p = SafePath.new('test_space_rw').join('test1')
+
+    SafeFile.open(p, 'w', 255) do |f|
+      f.write 'test332'
+    end
+
+    assert File.exist?(p)
+  end
+
+  test '::open should accept fs permissions with no block' do
+    p = SafePath.new('test_space_rw').join('test1')
+
+    f = SafeFile.open(p, 'w', 255)
+    f.close
+
+    assert File.exist?(p)
+  end
+
+  test '::open should work as new if no block passed' do
+    p = SafePath.new('test_space_r').join('test_file_rw')
+
+    f = SafeFile.open(p)
+    assert_equal SafeFile, f.class
+    f.close
+  end
+
+  ################################################################################
+  # ::read
+
+  test '::read should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.read @not_empty_fpath.to_s
+    end
+  end
+
+  test '::read should check pathspace permissions' do
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw')
+
+    fcontent = 'none'
+    assert_raises SecurityError do
+      fcontent = SafeFile.read(write_only_path)
+    end
+    assert_equal 'none', fcontent
+  end
+
+  test '::read should read file content' do
+    assert File.read(@not_empty_fpath), SafeFile.read(@not_empty_fpath)
+  end
+
+  ################################################################################
+  # .read
+
+  test '#read should check pathspace permissions' do
+    p = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    f = SafeFile.new(p, 'w')
+    assert_raises SecurityError do
+      f.read
+    end
+    f.close
+  end
+
+  test '#read should read read-only namespace' do
+    p = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+
+    f = SafeFile.new(p, 'r')
+    assert_equal 'I am not empty', f.read
+    f.close
+  end
+
+  ################################################################################
+  # .write
+
+  test '#write should check pathspace permissions' do
+    p = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+
+    f = SafeFile.new(p, 'r')
+    assert_raises SecurityError do
+      f.write 'junk'
+    end
+    f.close
+  end
+
+  test '#write should write to write namespace' do
+    p = SafePath.new('test_space_rw').join('test1')
+
+    f = SafeFile.new(p, 'w')
+    f.write 'good test'
+    f.close
+
+    f = SafeFile.new(p, 'r')
+    assert_equal 'good test', f.read
+    f.close
+
+    assert File.exist? p.to_s
+    File.delete p
+  end
+
+  ################################################################################
+  # .path
+
+  test '#path should return instance of SafePath' do
+    p = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+
+    f = SafeFile.new(p)
+    assert_equal SafePath, f.path.class
+    refute_equal p.object_id, f.path.object_id
+    assert_equal p, f.path
+  end
+
+  ################################################################################
+  # .close
+
+  test '#close should close the file' do
+    p = SafePath.new('test_space_w').join('test_file_rw')
+    f = SafeFile.new(p, 'w')
+    f.write 'test'
+    f.close
+  end
+
+  ################################################################################
+  # ::extname
+
+  test '::extname should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.extname 'bad/extention.rb'
+    end
+  end
+
+  test '::extname should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.extname read_only_path
+    SafeFile.extname write_only_path
+  end
+
+  test '::extname should return the extention only' do
+    assert_equal '.rb', SafeFile.extname(SafePath.new('test_space_r').join('test_file.rb'))
+    assert_equal '', SafeFile.extname(SafePath.new('test_space_r').join('test_file'))
+  end
+
+  ################################################################################
+  # ::basename
+
+  test '::basename should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.basename('some/evil/path.rb')
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.basename('some/evil/path.rb', '.rb')
+    end
+  end
+
+  test '::basename should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.basename read_only_path
+    SafeFile.basename write_only_path
+  end
+
+  test '::basename should should return the basename' do
+    p = SafePath.new('test_space_rw').join('myfile.rb')
+
+    assert_equal 'myfile.rb', SafeFile.basename(p)
+    assert_equal 'myfile', SafeFile.basename(p, '.rb')
+  end
+
+  ################################################################################
+  # ::readlines
+
+  test "::readlines shouldn't accept more than 2 and less than 1 arguments" do
+    p = SafePath.new('test_space_r').join('test_file_rw')
+    assert_raises ArgumentError do
+      SafeFile.readlines
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.readlines(p, 'junk_argument1', :junk_argument2)
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.readlines('junk/path/to/file.rb')
+    end
+  end
+
+  test '::readlines should check pathspace permissions' do
+    p = SafePath.new('test_space_w').join('test_file_rw')
+    assert_raises SecurityError do
+      SafeFile.readlines(p)
+    end
+  end
+
+  test '::readlines should read lines from file' do
+    p = SafePath.new('test_space_r').join('test_file_rw')
+    # Use file because this test should be independent on the rest of the functionality of SafeFile
+    File.open(p, 'w') do |f|
+      f.write "there are three\nlines in this file\nand eight words"
+    end
+
+    lines = SafeFile.readlines(p)
+
+    assert_equal 3, lines.length
+    assert_equal "there are three\n", lines[0]
+    assert_equal "lines in this file\n", lines[1]
+    assert_equal 'and eight words', lines[2]
+
+    lines = SafeFile.readlines(p, ' ')
+    assert_equal 8, lines.length
+    assert_equal 'there ', lines[0]
+  end
+
+  ################################################################################
+  # ::directory?
+
+  test '::directory? should accept only safe_path' do
+    assert_raises ArgumentError do
+      SafeFile.directory?('some/junk/path')
+    end
+  end
+
+  test '::directory? should NOT check for pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.directory?(read_only_path)
+    SafeFile.directory?(write_only_path)
+  end
+
+  test '::directory? should return true if the path is a directory and false otherwise' do
+    p = SafePath.new('test_space_r')
+    assert SafeFile.directory?(p)
+    refute SafeFile.directory?(p.join('test_file_rw_not_empty'))
+  end
+
+  ################################################################################
+  # ::exist? ::exists?
+
+  test '::exist? and ::exists? should accept only safe_path' do
+    assert_raises ArgumentError do
+      SafeFile.exist?('some/junk/path')
+    end
+
+    assert_raises ArgumentError do
+      SafeFile.exist?('some/junk/path')
+    end
+  end
+
+  test '::exist? and ::exists? should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.exist?(read_only_path)
+    SafeFile.exist?(write_only_path)
+    SafeFile.exist?(read_only_path)
+    SafeFile.exist?(write_only_path)
+  end
+
+  test 'exist? and exists? should return true if the file exists and false otherwise' do
+    real = SafePath.new('test_space_r').join('test_file_rw')
+    junk = SafePath.new('test_space_r').join('test_file_rw_junk')
+
+    assert SafeFile.exist?(real)
+    assert SafeFile.exist?(real)
+
+    refute SafeFile.exist?(junk)
+    refute SafeFile.exist?(junk)
+  end
+
+  ################################################################################
+  # ::file?
+
+  test '::file? should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.file?('some/junk.path')
+    end
+  end
+
+  test '::file? should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.file?(read_only_path)
+    SafeFile.file?(write_only_path)
+  end
+
+  test 'file? should return true of the path is file and false otherwise' do
+    file = SafePath.new('test_space_r').join('test_file_rw')
+    dir = SafePath.new('test_space_r')
+
+    assert SafeFile.file?(file)
+    refute SafeFile.file?(dir)
+  end
+
+  ################################################################################
+  # ::zero?
+
+  test '::zero? should accept only SafePath' do
+    assert_raises ArgumentError do
+      SafeFile.zero? SafePath.new('test_space_w').join!('test_file_rw').to_s
+    end
+  end
+
+  test '::zero? should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.zero?(read_only_path)
+    SafeFile.zero?(write_only_path)
+  end
+
+  test '::zero? should return true when the file is empty and false otherwise' do
+    assert SafeFile.zero? SafePath.new('test_space_rw').join!('test_file_rw')
+    refute SafeFile.zero?(SafePath.new('test_space_rw').join!('test_file_rw_not_empty'))
+  end
+
+  ################################################################################
+  # ::dirname
+
+  test '::dirname should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.dirname('some/junk/path')
+    end
+  end
+
+  test '::dirname should NOT check pathspace permissions' do
+    read_only_path = SafePath.new('test_space_r').join('test_file_rw_not_empty')
+    write_only_path = SafePath.new('test_space_w').join('test_file_rw_not_empty')
+
+    SafeFile.dirname(read_only_path)
+    SafeFile.dirname(write_only_path)
+  end
+
+  test '::dirname should return the directory' do
+    p = SafePath.new('test_space_r')
+
+    assert_equal SafePath, SafeFile.dirname(p.join('test_file_rw')).class
+    refute_equal p.object_id, SafeFile.dirname(p.join('test_file_rw')).object_id
+
+    assert_equal p.to_s, SafeFile.dirname(p.join('test_file_rw')).to_s
+  end
+
+  ################################################################################
+  # ::delete
+
+  test '::delete should accept safe_path only' do
+    assert_raises ArgumentError do
+      SafeFile.delete('test_path')
+    end
+  end
+
+  test '::delete should check pathspace permissions' do
+    assert_raises SecurityError do
+      SafeFile.delete(SafePath.new('test_space_r').join!('test_file_r'))
+    end
+  end
+
+  test '::delete should delete file/files' do
+    sp = SafePath.new('test_space_w').join!('new_test_file')
+
+    group = [SafePath.new('test_space_w').join!('new_test_file1'),
+             SafePath.new('test_space_w').join!('new_test_file2'),
+             SafePath.new('test_space_w').join!('new_test_file3')]
+
+    (group + [sp]).each do |fname|
+      # This test should't depend on the rest of the functionality of SafeFile
+      File.open(fname, 'w') { |f| f.write 'test' }
+    end
+
+    SafeFile.delete sp
+
+    refute File.exist?(sp)
+
+    SafeFile.delete(*group)
+
+    group.each do |fname|
+      refute File.exist?(fname)
+    end
+  end
+end