content_server 1.1.0 → 1.2.0

data/test/file_utils/time_modification_test.rb

@@ -0,0 +1,132 @@
+require 'fileutils'
+require 'time'
+require 'test/unit'
+
+require 'content_data'
+require 'file_indexing'
+require 'file_utils'
+require 'log'
+require 'params'
+
+module FileUtils
+  def FileUtils.parse_time time_str
+    return nil unless time_str.instance_of? String
+    seconds_from_epoch = Integer time_str  # Not using to_i here because it does not check string is integer.
+    time = Time.at seconds_from_epoch
+  end
+
+  module Test
+    class TestTimeModification < ::Test::Unit::TestCase
+      # directory where tested files will be placed: __FILE__/time_modification_test
+      RESOURCES_DIR = File.expand_path(File.dirname(__FILE__) + "/time_modification_test")
+      # minimal time that will be inserted in content
+      MOD_TIME_CONTENTS = FileUtils.parse_time("1306527039")
+      # minimal time that will be inserted in instance
+      MOD_TIME_INSTANCES = FileUtils.parse_time("1306527039")
+      #time_str =  "2002/02/01 02:23:59.000"
+      #MOD_TIME_INSTANCES = Time.strftime( time_str, '%Y/%m/%d %H:%M:%S.%L' )
+      DEVICE_NAME = "hd1"
+
+      @input_db
+      @mod_content_checksum = nil  # checksum of the content that was manually modified
+      @mod_instance_checksum = nil  # checksum of the instance that was manually modified
+
+      def setup
+        sizes = [500, 1000, 1500]
+        numb_of_copies = 2
+        test_file_name = "test_file"
+
+        Dir.mkdir(RESOURCES_DIR) unless (File.exists?(RESOURCES_DIR))
+        raise "Can't create writable working directory: #{RESOURCES_DIR}" unless \
+              (File.exists?(RESOURCES_DIR) and File.writable?(RESOURCES_DIR))
+        # prepare files for testing
+        sizes.each do |size|
+          file_path = "#{RESOURCES_DIR}/#{test_file_name}.#{size}"
+          file = File.open(file_path, "w", 0777) do |file|
+            content = Array.new
+            size.times do |i|
+              content.push(sprintf("%5d ", i))
+            end
+            file.puts(content)
+          end
+          File.utime File.atime(file_path), MOD_TIME_CONTENTS, file_path
+          numb_of_copies.times do |i|
+            ::FileUtils.cp(file_path, "#{file_path}.#{i}")
+          end
+        end
+
+        indexer = FileIndexing::IndexAgent.new
+        patterns = FileIndexing::IndexerPatterns.new
+        patterns.add_pattern(RESOURCES_DIR + '\*')
+        indexer.index(patterns)
+
+        @input_db = indexer.indexed_content
+      end
+
+      # This test compares two ways of ruby + OS to get mtime (modification file) of a file.
+      # We can see that in Windows there is a difference.
+      def test_local_os
+        Dir.mkdir(RESOURCES_DIR) unless (File.exists?(RESOURCES_DIR))
+        file_path = "#{RESOURCES_DIR}/local_os_test.test"
+        file = File.open(file_path, "w", 0777) do |file|
+          file.puts("kuku")
+        end
+        file_stats = File.stat(file_path)
+        Log.info "MOD_TIME_CONTENTS: #{MOD_TIME_CONTENTS}."
+        Log.info "MOD_TIME_CONTENTS: #{MOD_TIME_CONTENTS.to_i}."
+        Log.info "file_stat.mtime: #{file_stats.mtime}."
+        Log.info "file_stat.mtime: #{file_stats.mtime.to_i}."
+        Log.info "File.mtime: #{File.mtime(file_path)}."
+        Log.info "File.mtime: #{File.mtime(file_path).to_i}."
+        File.utime File.atime(file_path), MOD_TIME_CONTENTS, file_path
+        file_stats = File.stat(file_path)
+        Log.info "file_stat.mtime: #{file_stats.mtime}."
+        Log.info "file_stat.mtime: #{file_stats.mtime.to_i}."
+        Log.info "File.mtime: #{File.mtime(file_path)}."
+        Log.info "File.mtime: #{File.mtime(file_path).to_i}."
+
+        file_mtime = nil
+        file = File.open(file_path, "r") do |file|
+          Log.info "file.open.mtime = #{file.mtime}"
+          Log.info "file.open.mtime = #{file.mtime.to_i}"
+          file_mtime = file.mtime
+        end
+
+        assert_equal(MOD_TIME_CONTENTS, file_mtime)
+
+        # !!! This fails on windows with different timezone
+        # assert_equal(MOD_TIME_CONTENTS, file_stats.mtime)
+      end
+
+      def test_modify
+        # modified ContentData. Test files also were modified.
+        mod_db = FileUtils.unify_time(@input_db)
+
+        Log.info "==============="
+        Log.info @input_db.to_s
+        Log.info "==============="
+
+        # checking that content was modified according to the instance with minimal time
+        mod_db.each_instance { |checksum, size, content_mod_time, instance_mod_time, server, path|
+          next unless checksum.eql?(@mod_instance_checksum)
+          content_time =  FileUtils.parse_time(content_mod_time.to_s)
+          assert_equal(MOD_TIME_INSTANCES, content_time)
+          instance_time =  FileUtils.parse_time(instance_mod_time.to_s)
+          assert_equal(MOD_TIME_INSTANCES, instance_time)
+        }
+
+        # checking that files were actually modified
+        mod_db.each_instance { |checksum, size, content_mod_time, instance_mod_time, server, path|
+          indexer = FileIndexing::IndexAgent.new  # (instance.server_name, instance.device)
+          patterns = FileIndexing::IndexerPatterns.new
+          patterns.add_pattern(File.dirname(path) + '/*')     # this pattern index all files
+          indexer.index(patterns, mod_db)
+          p mod_db.to_s
+          p indexer.indexed_content.to_s
+          assert_equal(indexer.indexed_content, mod_db)
+          break
+        }
+      end
+    end
+  end
+end

data/test/params/params_spec.rb

@@ -0,0 +1,280 @@
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: The file contains 'Param' module tests
+
+require 'rspec'
+require 'yaml'
+
+require_relative '../../lib/params.rb'
+
+module Params
+  # make private methods or Params public for testing capability.
+  public_class_method :parse_command_line_arguments, \
+                      :raise_error_if_param_exists, :raise_error_if_param_does_not_exist, \
+                      :read_yml_params, :override_param
+
+  module Spec
+
+    describe 'Params::parameter' do
+
+      it 'should define a new parameters' do
+        Params.string 'par_str', 'sss' ,'desc_str'
+        Params.integer 'par_int',1 , 'desc_int'
+        Params.float 'par_float',2.6 , 'desc_float'
+        Params.boolean 'par_true', true, 'desc_true'
+        Params.boolean 'par_false',false , 'desc_false'
+        Params['par_str'].should eq 'sss'
+        Params['par_int'].should eq 1
+        Params['par_float'].should eq 2.6
+        Params['par_true'].should eq true
+        Params['par_false'].should eq false
+      end
+
+      it 'should raise an error for wrong parameter type definition.' do
+        expect { Params::Param.new 'bad_type', 5, 'non_existing_type', 'desc_bad_type' }.to raise_error
+      end
+
+      it 'should raise an error when trying to define twice the same parameter' do
+        Params.string 'only_once', '1st' ,''
+        expect { Params.string 'only_once', '2nd' ,'' }.to raise_error \
+              "Parameter:'only_once', can only be defined once."
+      end
+    end
+
+    describe 'Params::read_yml_params' do
+      it 'should raise error when yml parameter is not defined' do
+        expect { Params::read_yml_params StringIO.new 'not_defined: 10' }.to raise_error \
+              "Parameter:'not_defined' has not been defined and can not be overridden. " \
+              "It should first be defined through Param module methods:" \
+              "Params.string, Params.path, Params.integer, Params.float, Params.complex, or Params.boolean."
+      end
+
+      it 'Will test yml parameter loading' do
+        # string to other. Will not raise error. Instead a cast is made.
+        Params.string('tmp4str', 'string_value', 'tmp4 def')
+        expect { Params::read_yml_params StringIO.new 'tmp4str: strr' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4str: 4' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4str: 4.5' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4str: true' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4str: false' }.to_not raise_error
+
+        # override integer with other types.
+        Params.integer('tmp4int', 1, 'tmp4 def')
+        expect { Params::read_yml_params StringIO.new 'tmp4int: strr' }.to raise_error \
+          "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'String'."
+        expect { Params::read_yml_params StringIO.new 'tmp4int: 4' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4int: 4.5' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'Float'."
+        expect { Params::read_yml_params StringIO.new 'tmp4int: true' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'TrueClass'."
+        expect { Params::read_yml_params StringIO.new 'tmp4int: false' }.to raise_error \
+              "Parameter:'tmp4int' type:'Integer' but value type to override " \
+                      "is:'FalseClass'."
+
+        # override float with other types.
+        Params.float('tmp4float', 1.1, 'tmp4 def')
+        expect { Params::read_yml_params StringIO.new 'tmp4float: strr' }.to raise_error \
+          "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'String'."
+        expect { Params::read_yml_params StringIO.new 'tmp4float: 4' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4float: 4.5' }.to_not raise_error
+        expect { Params::read_yml_params StringIO.new 'tmp4float: true' }.to raise_error \
+              "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'TrueClass'."
+        expect { Params::read_yml_params StringIO.new 'tmp4float: false' }.to raise_error \
+              "Parameter:'tmp4float' type:'Float' but value type to override " \
+                      "is:'FalseClass'."
+        # override boolean with other types.
+        Params.boolean('tmp4true', true, 'tmp4 def')
+        expect { Params::read_yml_params StringIO.new 'tmp4true: strr' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'String'."
+        expect { Params::read_yml_params StringIO.new 'tmp4true: 4' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'Fixnum'."
+        expect { Params::read_yml_params StringIO.new 'tmp4true: 4.5' }.to raise_error \
+              "Parameter:'tmp4true' type:'Boolean' but value type to override " \
+                      "is:'Float'."
+        expect { Params::read_yml_params StringIO.new 'tmp4true: true' }.to_not raise_error
+        expect { Params.read_yml_params StringIO.new 'tmp4true: false' }.to_not raise_error
+
+        Params.boolean('tmp4False', true, 'tmp4 def')
+        expect { Params.read_yml_params StringIO.new 'tmp4False: strr' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'String'."
+        expect { Params.read_yml_params StringIO.new 'tmp4False: 4' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'Fixnum'."
+        expect { Params.read_yml_params StringIO.new 'tmp4False: 4.5' }.to raise_error \
+              "Parameter:'tmp4False' type:'Boolean' but value type to override " \
+                      "is:'Float'."
+        expect { Params.read_yml_params StringIO.new 'tmp4False: true' }.to_not raise_error
+        expect { Params.read_yml_params StringIO.new 'tmp4False: false' }.to_not raise_error
+
+      end
+
+      it 'should raise error when yml file format is bad' do
+        expect { Params.read_yml_params StringIO.new '"bad yml format' }.to raise_error
+      end
+
+      it 'should override defined values with yml values' do
+        Params.string('tmp5str', 'aaa', 'tmp5 def')
+        Params.integer('tmp5int', 11, 'tmp5 def')
+        Params.float('tmp5float', 11.11, 'tmp5 def')
+        Params.boolean('tmp5true', true, 'tmp5 def')
+        Params.boolean('tmp5false', false, 'tmp5 def')
+        Params.read_yml_params StringIO.new "tmp5str: bbb\ntmp5int: 12\ntmp5float: 12.12\n"
+        Params.read_yml_params StringIO.new "tmp5true: false\ntmp5false: true\n"
+        Params['tmp5str'].should eq 'bbb'
+        Params['tmp5int'].should eq 12
+        Params['tmp5float'].should eq 12.12
+        Params['tmp5true'].should eq false
+        Params['tmp5false'].should eq true
+      end
+    end
+
+    describe 'Params.parse_command_line_arguments' do
+      it 'should raise error when command line parameter is not defined' do
+        expect { Params.parse_command_line_arguments ['--new_param=9]'] }.to raise_error
+      end
+
+      it 'should parse parameter from command line.' do
+        # Override string with types.
+        Params.string('tmp6str', 'dummy', 'tmp6str def')
+        expect { Params.parse_command_line_arguments ['--tmp6str=9'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6str=8.1'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6str=ff'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6str=true'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6str=false'] }.to_not raise_error
+
+        # from fixnum to other types.
+        Params.integer('tmp6', 8, 'tmp6 def')
+        expect { Params.parse_command_line_arguments ['--tmp6=9'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6=8.1'] }.to raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6=ff'] }.to raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6=true'] }.to raise_error
+        expect { Params.parse_command_line_arguments ['--tmp6=false'] }.to raise_error
+
+        # from float to other types.
+        Params.float('tmp7', 8.9, 'tmp7 def')
+        # Casting fix num to float
+        expect { Params.parse_command_line_arguments ['--tmp7=9'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp7=3.4'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp7=ff'] }.to raise_error
+        expect { Params.parse_command_line_arguments ['--tmp7=true'] }.to raise_error
+        expect { Params.parse_command_line_arguments ['--tmp7=false'] }.to raise_error
+
+        # from TrueClass to other types.
+        Params.boolean('tmp8', true, 'tmp8 def')
+        expect { Params.parse_command_line_arguments ['--tmp8=9'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp8=3.4'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp8=ff'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp8=true'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp8=false'] }.to_not raise_error
+
+        # from FalseClass to other types.
+        Params.boolean('tmp9', false, 'tmp9 def')
+        expect { Params.parse_command_line_arguments ['--tmp9=9'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp9=3.4'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp9=ff'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp9=true'] }.to_not raise_error
+        expect { Params.parse_command_line_arguments ['--tmp9=false'] }.to_not raise_error
+      end
+    end
+
+    describe 'Params.init' do
+      it 'should override command line arguments correctly.' do
+        File.stub(:exist?).and_return false
+        # Override string with types.
+        Params.string('tmp6str2', 'dummy', 'tmp6str def')
+        expect { Params.init ['--tmp6str2=9'] }.to_not raise_error
+        expect { Params.init ['--tmp6str2=8.1'] }.to_not raise_error
+        expect { Params.init ['--tmp6str2=ff'] }.to_not raise_error
+        expect { Params.init ['--tmp6str2=true'] }.to_not raise_error
+        expect { Params.init ['--tmp6str2=false'] }.to_not raise_error
+
+        # from fixnum to other types.
+        Params.integer('tmp6Fixnum2', 8, 'tmp6 def')
+        expect { Params.init ['--tmp6Fixnum2=9'] }.to_not raise_error
+        expect { Params.init ['--tmp6Fixnum2=8.1'] }.to raise_error
+        expect { Params.init ['--tmp6Fixnum2=ff'] }.to raise_error
+        expect { Params.init ['--tmp6Fixnum2=true'] }.to raise_error
+        expect { Params.init ['--tmp6Fixnum2=false'] }.to raise_error
+
+        # from float to other types.
+        Params.float('tmp7float2', 8.9, 'tmp7 def')
+        # Casting fix num to float
+        expect { Params.init ['--tmp7float2=9'] }.to_not raise_error
+        expect { Params.init ['--tmp7float2=3.4'] }.to_not raise_error
+        expect { Params.init ['--tmp7float2=ff'] }.to raise_error
+        expect { Params.init ['--tmp7float2=true'] }.to raise_error
+        expect { Params.init ['--tmp7float2=false'] }.to raise_error
+
+        # from TrueClass to other types.
+        Params.boolean('tmp8true2', true, 'tmp8 def')
+        expect { Params.init ['--tmp8true2=9'] }.to raise_error
+        expect { Params.init ['--tmp8true2=3.4'] }.to raise_error
+        expect { Params.init ['--tmp8true2=ff'] }.to raise_error
+        expect { Params.init ['--tmp8true2=true'] }.to_not raise_error
+        expect { Params.init ['--tmp8true2=false'] }.to_not raise_error
+
+        # from FalseClass to other types.
+        Params.boolean('tmp9false2', false, 'tmp9 def')
+        expect { Params.init ['--tmp9false2=9'] }.to raise_error
+        expect { Params.init ['--tmp9false2=3.4'] }.to raise_error
+        expect { Params.init ['--tmp9false2=ff'] }.to raise_error
+        expect { Params.init ['--tmp9false2=true'] }.to_not raise_error
+        expect { Params.init ['--tmp9false2=false'] }.to_not raise_error
+      end
+
+      it 'should override defined values with command line values' do
+        File.stub(:exist?).and_return false
+        Params.string('tmp10str', 'aaa', 'tmp10 def')
+        Params.integer('tmp10int', 11, 'tmp10 def')
+        Params.float('tmp10float', 11.11, 'tmp10 def')
+        Params.boolean('tmp10true', true, 'tmp10 def')
+        Params.boolean('tmp10false', false, 'tmp10 def')
+        Params.init ['--tmp10str=bbb', '--tmp10int=12', '--tmp10float=12.12', \
+                       '--tmp10true=false', '--tmp10false=true']
+        Params['tmp10str'].should eq 'bbb'
+        Params['tmp10int'].should eq 12
+        Params['tmp10float'].should eq 12.12
+        Params['tmp10true'].should eq false
+        Params['tmp10false'].should eq true
+      end
+
+      it 'init should override parameters with file and command' do
+        Params.string('init_param', 'code', '')
+        File.stub(:exist?).and_return true
+        File.stub(:open).and_return StringIO.new 'init_param: yml'
+        Params.init ['--conf_file=dummy_file', '--init_param=command-line']
+        Params['init_param'].should eq 'command-line'
+      end
+
+      it 'init should override parameters with file only' do
+        Params.string('init_param2', 'code', '')
+        File.stub(:exist?).and_return true
+        File.stub(:open).and_return StringIO.new 'init_param2: yml'
+        Params.init ['--conf_file=dummy_file']
+        Params['init_param2'].should eq 'yml'
+      end
+
+      it 'init should override parameters with command line only' do
+        Params.string('init_param3', 'code', '')
+        File.stub(:exist?).and_return false
+        Params.init ['--init_param3=command-line']
+        Params['init_param3'].should eq 'command-line'
+      end
+
+      it 'init should not override any parameters' do
+        Params.string('init_param4', 'code', '')
+        File.stub(:exist?).and_return false
+        Params.init []
+        Params['init_param4'].should eq 'code'
+      end
+    end
+  end
+end
+

data/test/params/params_test.rb

@@ -0,0 +1,43 @@
+# Author: Yaron Dror (yaron.dror.bb@gmail.com)
+# Description: Params test file.
+# run: rake test.
+# Note: This file will be tested along with all project tests.
+
+require 'params'
+require 'test/unit'
+require_relative '../../lib/params.rb'
+
+
+class TestLog < Test::Unit::TestCase
+
+  def test_parsing_of_the_defined_parameters
+    #  Define options
+    Params.integer('remote_server1', 3333,
+                   'Listening port for backup server content data.')
+    Params.string('backup_username1', 'tmp', 'Backup server username.')
+    Params.string('backup_password1', 'tmp', 'Backup server password.')
+    Params.string('backup_destination_folder1', '',
+                  'Backup server destination folder, default is the relative local folder.')
+    Params.string('content_data_path1', File.expand_path('~/.bbfs/var/content.data'),
+                  'ContentData file path.')
+    Params.string('monitoring_config_path1', File.expand_path('~/.bbfs/etc/file_monitoring.yml'),
+                  'Configuration file for monitoring.')
+    Params.float('time_to_start1', 0.03,
+                 'Time to start monitoring')
+
+    cmd = ['--remote_server1=2222', '--backup_username1=rami', '--backup_password1=kavana',
+           '--backup_destination_folder1=C:\Users\Alexey\Backup',
+           '--content_data_path1=C:\Users\Alexey\Content',
+           '--monitoring_config_path1=C:\Users\Alexey\Config',
+           '--time_to_start1=1.5']
+    Params.init cmd
+    assert_equal(2222, Params['remote_server1'])
+    assert_equal('rami', Params['backup_username1'])
+    assert_equal('kavana', Params['backup_password1'])
+    assert_equal('C:\Users\Alexey\Backup', Params['backup_destination_folder1'])
+    assert_equal('C:\Users\Alexey\Content', Params['content_data_path1'])
+    assert_equal('C:\Users\Alexey\Config', Params['monitoring_config_path1'])
+    assert_equal(1.5, Params['time_to_start1'])
+  end
+end
+

data/test/run_in_background/run_in_background_test.rb

@@ -0,0 +1,122 @@
+require 'test/unit'
+require 'run_in_background'
+
+# TODO break to number of small tests according to functionality
+# TODO rewrite with Shoulda/RSpec
+class TestRunInBackground < Test::Unit::TestCase
+  #include RunInBackground
+
+  if RUBY_PLATFORM =~ /linux/ or RUBY_PLATFORM =~ /darwin/
+    OS = :LINUX
+  elsif RUBY_PLATFORM =~ /mingw/ or RUBY_PLATFORM =~ /ms/ or RUBY_PLATFORM =~ /win/
+    require 'sys/uname'
+    OS = :WINDOWS
+  else
+    raise "Unsupported platform #{RUBY_PLATFORM}"
+  end
+
+  def setup
+    @good_daemon = "good_daemon_test"
+    @good_daemonize = "good_daemonize_test"
+    @good_win32daemon = "good_win32daemon_test"
+    @bad_daemon = "bad_daemon_test"
+    @binary = File.join(File.dirname(File.expand_path(__FILE__)), 'test_app')
+    @binary.tr!('/','\\') if OS == :WINDOWS
+    File.chmod(0755, @binary) if OS == :LINUX && !File.executable?(@binary)
+    @absent_binary = File.join(File.dirname(File.expand_path(__FILE__)), "test_app_absent")
+  end
+
+  def test_functionality
+    if OS == :WINDOWS && Sys::Uname.sysname =~ /(Windows 7)/
+      skip "This test shouldn't be run on #{$1}"
+    end
+
+    # test start
+    # test application should actually start here
+    assert_nothing_raised{ RunInBackground.start(@binary, ["1000"], @good_daemon) }
+    assert_raise(ArgumentError) { RunInBackground.start(@absent_binary, ["1000"], @bad_daemon) }
+
+    # start arguments have to be defined
+    assert_raise(ArgumentError) { RunInBackground.start(["1000"], @bad_daemon) }
+    assert_raise(ArgumentError) { RunInBackground.start(nil, ["1000"], @bad_daemon) }
+    assert_raise(ArgumentError) { RunInBackground.start(@absent_binary, nil, @bad_daemon) }
+    assert_raise(ArgumentError) { RunInBackground.start(@absent_binary, ["1000"], nil) }
+
+    # test exists?
+    assert_raise(ArgumentError) { RunInBackground.exists? }
+    assert_equal(false, RunInBackground.exists?(@bad_daemon))
+    assert_equal(true, RunInBackground.exists?(@good_daemon))
+
+    # test running?
+    # if stop method will be public need to add test checks actually stopped daemon
+    assert_raise(ArgumentError) { RunInBackground.running? }
+    assert_raise(ArgumentError) { RunInBackground.running?(@bad_daemon) }
+    assert_equal(true, RunInBackground.running?(@good_daemon))
+
+    # test daemonazing (start!)
+    # from the nature of daemonization need to run it from another process that will be daemonized
+    ruby = (OS == :WINDOWS ? RunInBackground::RUBY_INTERPRETER_PATH : "ruby")
+    cmd = "#{ruby} -Ilib #{@binary} 50 #{@good_daemonize}"
+    pid = spawn(cmd)
+    Process.waitpid pid
+    # checking that it indeed was daemonized
+    # e.i. process was killed and code rerun in background
+    # it takes time to the OS to remove process, so using a timeout here
+    0.upto(RunInBackground::TIMEOUT) do
+      begin
+        Process.kill(0, pid)
+      rescue Errno::ESRCH
+        break
+      end
+      sleep 1
+    end
+    assert_raise(Errno::ESRCH) { Process.kill(0, pid) }
+    assert_equal(true, RunInBackground.exists?(@good_daemonize))
+    assert_equal(true, RunInBackground.running?(@good_daemonize))
+
+    # test running win32 specific daemon (start_win32service)
+    # wrapper script will be run
+    if OS == :WINDOWS
+      win32service_arg = [RunInBackground::RUBY_INTERPRETER_PATH, @binary, 1000]
+      assert_nothing_raised{
+        RunInBackground.start_win32service(RunInBackground::WRAPPER_SCRIPT,
+                                           win32service_arg, @good_win32daemon)
+      }
+      assert_equal(true, RunInBackground.exists?(@good_win32daemon))
+      assert_equal(true, RunInBackground.running?(@good_win32daemon))
+    else
+      assert_raise(NotImplementedError) {
+        RunInBackground.start_win32service(@absent_binary, [], @bad_daemon)
+      }
+    end
+
+    # uncomment following lines if there is a suspicion that something gone wrong
+    # inspired by bug caused by coworking of daemon_wrapper an logger
+    #sleep 10
+    #assert_equal(true, RunInBackground.running?(@good_daemon))
+    #assert_equal(true, RunInBackground.running?(@good_daemonize))
+    #assert_equal(true, RunInBackground.running?(@good_win32daemon))
+
+    # test delete
+    # test application should actually stop here
+    assert_raise(ArgumentError) { RunInBackground.delete }
+    assert_raise(ArgumentError) { RunInBackground.delete(@bad_daemon) }
+    assert_nothing_raised { RunInBackground.delete(@good_daemon) }
+    assert_equal(false, RunInBackground.exists?(@good_daemon))
+
+    assert_nothing_raised { RunInBackground.delete(@good_daemonize) }
+    assert_equal(false, RunInBackground.exists?(@good_daemonize))
+
+    # actuall only for Windows platform
+    if RunInBackground.exists?(@good_win32daemon)
+      assert_nothing_raised { RunInBackground.delete(@good_win32daemon) }
+      assert_equal(false, RunInBackground.exists?(@good_win32daemon))
+    end
+  end
+
+  def teardown
+    RunInBackground.delete @good_daemon if RunInBackground.exists? @good_daemon
+    RunInBackground.delete @good_daemonize if RunInBackground.exists? @good_daemonize
+    RunInBackground.delete @good_win32daemon if RunInBackground.exists? @good_win32daemon
+  end
+end

data/test/run_in_background/test_app

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# Toy script used for RunInBackground tests.
+# usage: $0 number_of_iterations [daemon_name_if_daemonized]
+
+DBG = false  # NOTE be sure to disable it in production 
+
+begin
+  begin
+    require 'log'
+    require 'params'
+  rescue LoadError
+    $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'lib'))
+    $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..'))
+    require 'log'
+    require 'params'
+  end
+
+  # On WindowsXP log can be found under:
+  # C:/Documents and Settings/NetworkService/.bbfs/test_app_<pid>.log
+  Params['log_file_name'] = File.join(Dir.home, '.bbfs', "#{File.basename(__FILE__)}_#{Process.pid}.log")
+  Params['log_write_to_console'] = false
+  if DBG
+    Params['log_debug_level'] = 1
+    Log.init
+  end
+
+  # app should be run in background
+  if ARGV.size == 2 
+    begin
+      require 'run_in_background'
+    rescue LoadError
+      $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'lib'))
+      $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..'))
+      require 'run_in_background'
+    end
+
+    Log.debug1 "Before run in background: PID #{Process.pid}"
+    # ARGV.pop returns frozen string and thus causes a failure of Service.create
+    # to fix it new string with the same content created.
+    RunInBackground.start!(String.new(ARGV.pop))
+    # if got here then error
+    Log.error "After run in background: ERROR"
+  end
+
+  max = (ARGV.size > 0 && ARGV[0] != nil && ARGV[0].to_i > 0)? ARGV[0].to_i : 200
+
+  while max > 0
+    Log.debug1 "#{max}"
+    sleep 1
+    max -= 1
+  end
+
+rescue Exception => err
+  Log.error "Wrapper error: #{err}"
+  raise
+end