content_server 1.5.0 → 1.6.0

data/test/run_in_background/run_in_background_test.rb

@@ -1,122 +0,0 @@
-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
-  Params.init([])
-
-  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

@@ -1,59 +0,0 @@
-#!/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
-
-  # 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")
-  if DBG
-    begin
-      require 'params'
-      require 'log'
-    rescue LoadError
-      $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'lib'))
-      $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', '..'))
-      require 'params'
-      require 'log'
-    end
-    Params.init Array.new
-    Params['log_debug_level'] = 1
-    Params['log_write_to_console'] = false
-    Params['log_write_to_file'] = true
-    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}" if DBG
-    # 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" if DBG
-  end
-
-  max = (ARGV.size > 0 && ARGV[0] != nil && ARGV[0].to_i > 0)? ARGV[0].to_i : 200
-
-  while max > 0
-    Log.debug1 "#{max}" if DBG
-    sleep 1
-    max -= 1
-  end
-
-rescue Exception => err
-  Log.error "Wrapper error: #{err}" if DBG
-  raise
-end