win32-service 0.6.1-x86-mswin32-60

data/test/tc_daemon.rb

@@ -0,0 +1,55 @@
+#########################################################################
+# tc_daemon.rb
+#
+# Test suite for the Win32::Daemon class. You should run this test via
+# the 'rake test' or 'rake test_daemon' tasks.
+#
+# These tests are rather limited, since the acid test is to install
+# your daemon as a service and see how it behaves.
+#########################################################################
+require 'win32/daemon'
+require 'test/unit'
+include Win32
+
+class TC_Daemon < Test::Unit::TestCase
+   def setup
+      @daemon = Daemon.new
+   end
+   
+   def test_version
+      assert_equal('0.6.1', Daemon::VERSION)
+   end
+   
+   def test_constructor
+      assert_respond_to(Daemon, :new)
+      assert_nothing_raised{ Daemon.new }
+      assert_raises(ArgumentError){ Daemon.new(1) } # No arguments by default
+   end
+   
+   def test_mainloop
+      assert_respond_to(@daemon, :mainloop)
+   end
+   
+   def test_state
+      assert_respond_to(@daemon, :state)
+   end
+   
+   def test_running
+      assert_respond_to(@daemon, :running?)
+   end
+   
+   def test_constants
+      assert_not_nil(Daemon::CONTINUE_PENDING)
+      assert_not_nil(Daemon::PAUSE_PENDING)
+      assert_not_nil(Daemon::PAUSED)
+      assert_not_nil(Daemon::RUNNING)
+      assert_not_nil(Daemon::START_PENDING)
+      assert_not_nil(Daemon::STOP_PENDING)
+      assert_not_nil(Daemon::STOPPED)
+      assert_not_nil(Daemon::IDLE) 
+   end
+   
+   def teardown
+      @daemon = nil
+   end
+end

data/test/tc_service.rb

@@ -0,0 +1,260 @@
+##########################################################################
+# tc_service.rb
+# 
+# Test case for the Win32::Service class.
+##########################################################################
+require 'win32/service'
+require 'socket'
+require 'test/unit'
+
+class TC_Win32_Service < Test::Unit::TestCase
+   def setup
+      @display_name = "Task Scheduler"
+      @service_name = "Schedule"      
+      @service_stat = nil
+      @services     = []
+   end
+   
+   def wait_for_status(status)
+      sleep 0.1 while Win32::Service.status(@service_name).current_state != status
+   end
+
+   def test_version
+      assert_equal('0.6.1', Win32::Service::VERSION)
+   end
+
+   def test_service_configure
+      assert_respond_to(Win32::Service, :configure)
+   end
+   
+   def test_service_configure_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.configure }
+      assert_raise(ArgumentError){ Win32::Service.configure('bogus') }
+      assert_raise(ArgumentError){ Win32::Service.configure('bogus', 'bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', nil, :description => 'Test') }
+      assert_raise(Win32::Service::Error){ Win32::Service.configure('x', 'y', :description => 'Test') }      
+   end
+   
+   def test_services_basic
+      assert_respond_to(Win32::Service, :services)
+      assert_nothing_raised{ Win32::Service.services }
+      assert_nothing_raised{ Win32::Service.services(nil) }
+      assert_nothing_raised{ Win32::Service.services(nil, 'network') }
+   end
+   
+   def test_services_non_block_form
+      assert_nothing_raised{ @services = Win32::Service.services }
+      assert_kind_of(Array, @services)
+      assert_kind_of(Struct::ServiceInfo, @services[0])
+   end
+   
+   def test_services_block_form
+      assert_nothing_raised{ Win32::Service.services{ |s| @services << s } }
+      assert_kind_of(Array, @services)
+      assert_kind_of(Struct::ServiceInfo, @services[0])      
+   end
+      
+   def test_services_expected_errors
+      assert_raise(TypeError){ Win32::Service.services(1) }
+      assert_raise(TypeError){ Win32::Service.services(nil, 1) }
+      assert_raise(ArgumentError){ Win32::Service.services(nil, 'network', 1) }
+      assert_raise(Win32::Service::Error){ Win32::Service.services('bogus') }
+   end   
+   
+   def test_delete
+      assert_respond_to(Win32::Service, :delete)
+   end
+   
+   def test_delete_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.delete }
+      assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.delete('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.delete('x', 'y', 'z') }
+   end
+   
+   def test_service_pause_and_resume
+      assert_respond_to(Win32::Service, :pause)
+      assert_respond_to(Win32::Service, :resume)
+      assert_nothing_raised{ Win32::Service.pause(@service_name) }
+      assert_nothing_raised{ wait_for_status('paused') }
+      assert_nothing_raised{ Win32::Service.pause(@service_name) }  
+      assert_nothing_raised{ Win32::Service.resume(@service_name) }
+      assert_nothing_raised{ wait_for_status('running') }
+   end
+   
+   def test_pause_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.pause }
+      assert_raise(Win32::Service::Error){ Win32::Service.pause('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.pause('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.pause('x', 'y', 'z') }
+   end
+   
+   def test_resume_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.resume }
+      assert_raise(Win32::Service::Error){ Win32::Service.resume('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.resume('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.resume('bogus', 'bogus', 'a') }
+   end          
+   
+   def test_service_stop_and_start
+      assert_respond_to(Win32::Service, :stop)
+      assert_respond_to(Win32::Service, :start)
+      assert_nothing_raised{ Win32::Service.stop(@service_name) }
+      assert_nothing_raised{ wait_for_status('stopped') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop(@service_name) }  
+      assert_nothing_raised{ Win32::Service.start(@service_name) }
+      assert_nothing_raised{ wait_for_status('running') }
+   end
+   
+   def test_stop_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.stop }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.stop('x', 'y', 'z') }
+   end
+   
+   def test_start_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.start }
+      assert_raise(Win32::Service::Error){ Win32::Service.start(@service_name) } # Started
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus', 'bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('bogus', 'bogus', 'a') }
+      assert_raise(Win32::Service::Error){ Win32::Service.start('a', 'b', 'c', 'd') }
+   end   
+   
+   def test_service_stop_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.stop }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.stop('bogus', 'bogus') }
+      assert_raise(ArgumentError){ Win32::Service.stop('a', 'b', 'c') }
+   end
+
+   def test_service_status_basic
+      assert_respond_to(Win32::Service, :status)
+      assert_nothing_raised{ Win32::Service.status(@service_name) }
+      assert_kind_of(Struct::ServiceStatus, Win32::Service.status(@service_name))
+   end
+
+   def test_service_get_service_name_basic
+      assert_respond_to(Win32::Service, :get_service_name)
+      assert_nothing_raised{ Win32::Service.get_service_name(@display_name) }
+      assert_kind_of(String, Win32::Service.get_service_name(@display_name))
+   end
+
+   def test_service_getservicename_alias_basic
+      assert_respond_to(Win32::Service, :getservicename)
+      assert_nothing_raised{ Win32::Service.getservicename(@display_name) }
+      assert_kind_of(String, Win32::Service.getservicename(@display_name))
+   end
+
+   def test_service_get_service_name
+      assert_equal(@service_name, Win32::Service.get_service_name(@display_name))
+      assert_equal(@service_name, Win32::Service.getservicename(@display_name))
+   end
+
+   def test_service_get_service_name_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.get_service_name }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_service_name('foo','bogus') }
+      assert_raise(ArgumentError){ Win32::Service.get_service_name('x', 'y', 'z') }
+   end
+
+   def test_service_get_display_name_basic
+      assert_respond_to(Win32::Service, :get_display_name)
+      assert_nothing_raised{ Win32::Service.get_display_name(@service_name) }
+      assert_kind_of(String, Win32::Service.get_display_name(@service_name))
+   end
+
+   def test_service_getdisplayname_alias_basic
+      assert_respond_to(Win32::Service, :getdisplayname)
+      assert_nothing_raised{ Win32::Service.getdisplayname(@service_name) }
+      assert_kind_of(String, Win32::Service.getdisplayname(@service_name))
+   end
+
+   def test_service_get_display_name
+      assert_equal(@display_name, Win32::Service.get_display_name(@service_name))
+      assert_equal(@display_name, Win32::Service.getdisplayname(@service_name))
+   end
+
+   def test_service_get_display_name_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.get_display_name }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('bogus') }
+      assert_raise(Win32::Service::Error){ Win32::Service.get_display_name('foo','bogus') }
+      assert_raise(ArgumentError){ Win32::Service.get_display_name('x', 'y', 'z') }
+   end
+
+   def test_service_exists
+      assert_respond_to(Win32::Service, :exists?)
+      assert_nothing_raised{ Win32::Service.exists?('W32Time') }
+      assert_equal(true, Win32::Service.exists?('W32Time'))
+      assert_equal(false, Win32::Service.exists?('foobar'))
+   end
+
+   def test_service_exists_expected_errors
+      assert_raises(ArgumentError){ Win32::Service.exists? }
+      assert_raises(Win32::Service::Error){Win32::Service.exists?('foo', 'bogushost') }
+      assert_raises(ArgumentError){ Win32::Service.exists?('foo', 'bar', 'baz') }
+   end
+      
+   def test_scm_security_constants
+      assert_not_nil(Win32::Service::MANAGER_ALL_ACCESS)
+      assert_not_nil(Win32::Service::MANAGER_CREATE_SERVICE)
+      assert_not_nil(Win32::Service::MANAGER_CONNECT)
+      assert_not_nil(Win32::Service::MANAGER_ENUMERATE_SERVICE)
+      assert_not_nil(Win32::Service::MANAGER_LOCK)
+      assert_not_nil(Win32::Service::MANAGER_QUERY_LOCK_STATUS)
+   end
+
+   def test_service_specific_constants
+      assert_not_nil(Win32::Service::ALL_ACCESS)
+      assert_not_nil(Win32::Service::CHANGE_CONFIG)
+      assert_not_nil(Win32::Service::ENUMERATE_DEPENDENTS)
+      assert_not_nil(Win32::Service::INTERROGATE)
+      assert_not_nil(Win32::Service::PAUSE_CONTINUE)
+      assert_not_nil(Win32::Service::QUERY_CONFIG)
+      assert_not_nil(Win32::Service::QUERY_STATUS)
+      assert_not_nil(Win32::Service::STOP)
+      assert_not_nil(Win32::Service::START)
+      assert_not_nil(Win32::Service::USER_DEFINED_CONTROL)
+   end
+
+   def test_service_type_constants
+      assert_not_nil(Win32::Service::FILE_SYSTEM_DRIVER)
+      assert_not_nil(Win32::Service::KERNEL_DRIVER)
+      assert_not_nil(Win32::Service::WIN32_OWN_PROCESS)
+      assert_not_nil(Win32::Service::WIN32_SHARE_PROCESS)
+      assert_not_nil(Win32::Service::INTERACTIVE_PROCESS)
+   end
+
+   def test_service_start_option_constants
+      assert_not_nil(Win32::Service::AUTO_START)
+      assert_not_nil(Win32::Service::BOOT_START)
+      assert_not_nil(Win32::Service::DEMAND_START)
+      assert_not_nil(Win32::Service::DISABLED)
+      assert_not_nil(Win32::Service::SYSTEM_START)
+   end
+
+   def test_service_error_control_constants
+      assert_not_nil(Win32::Service::ERROR_IGNORE)
+      assert_not_nil(Win32::Service::ERROR_NORMAL)
+      assert_not_nil(Win32::Service::ERROR_SEVERE)
+      assert_not_nil(Win32::Service::ERROR_CRITICAL)
+   end
+
+   def test_service_state_constants
+      assert_not_nil(Win32::Service::CONTINUE_PENDING)
+      assert_not_nil(Win32::Service::PAUSE_PENDING)
+      assert_not_nil(Win32::Service::PAUSED)
+      assert_not_nil(Win32::Service::RUNNING)
+      assert_not_nil(Win32::Service::START_PENDING)
+      assert_not_nil(Win32::Service::STOP_PENDING)
+      assert_not_nil(Win32::Service::STOPPED)      
+   end
+   
+   def teardown
+      @display_name = nil
+      @service_name = nil
+      @service_stat = nil
+      @services     = nil
+   end
+end

data/test/tc_service_create.rb

@@ -0,0 +1,83 @@
+########################################################################
+# tc_service_create.rb
+#
+# Test case for the Service.create method. This test case will create
+# a dummy (notepad) service. It won't actually run of course.
+########################################################################
+require 'win32/service'
+require 'test/unit'
+
+class TC_Service_Create < Test::Unit::TestCase
+   def setup
+      @notepad = "C:\\windows\\system32\\notepad.exe"
+      @service = 'notepad'
+      @info    = nil
+   end
+
+   def test_create_basic
+      assert_respond_to(Win32::Service, :new)
+      assert_respond_to(Win32::Service, :create)
+   end
+
+   def test_create_with_minimal_options
+      assert_nothing_raised{
+         Win32::Service.new(@service, nil, :binary_path_name => @notepad)
+      }
+
+      assert_equal(true, Win32::Service.exists?(@service))
+      assert_nothing_raised{ @info = Win32::Service.config_info(@service) }
+
+      assert_equal('own process, interactive', @info.service_type)
+      assert_equal('demand start', @info.start_type)
+      assert_equal('normal', @info.error_control)
+      assert_equal(@notepad, @info.binary_path_name)
+      assert_equal('', @info.load_order_group)
+      assert_equal(0, @info.tag_id)
+      assert_equal([], @info.dependencies)
+      assert_equal('LocalSystem', @info.service_start_name)
+      assert_equal('notepad', @info.display_name)
+   end
+
+   def test_create_with_most_options
+      assert_nothing_raised{
+         Win32::Service.new(@service, nil,
+            :display_name     => 'Notepad Test',
+            :desired_access   => Win32::Service::ALL_ACCESS,
+            :service_type     => Win32::Service::WIN32_OWN_PROCESS,
+            :start_type       => Win32::Service::DISABLED,
+            :error_control    => Win32::Service::ERROR_IGNORE,
+            :binary_path_name => @notepad,
+            :load_order_group => 'Network',
+            :dependencies     => 'W32Time',
+            :description      => 'Test service. Please delete me'
+         )
+      }
+      assert_equal(true, Win32::Service.exists?(@service))
+      assert_nothing_raised{ @info = Win32::Service.config_info(@service) }
+      
+      assert_equal('own process', @info.service_type)
+      assert_equal('disabled', @info.start_type)
+      assert_equal('ignore', @info.error_control)
+      assert_equal(@notepad, @info.binary_path_name)
+      assert_equal('Network', @info.load_order_group)
+      assert_equal(0, @info.tag_id)
+      assert_equal(['W32Time'], @info.dependencies)
+      assert_equal('LocalSystem', @info.service_start_name)
+      assert_equal('Notepad Test', @info.display_name)      
+   end
+
+   def test_create_expected_errors
+      assert_raise(ArgumentError){ Win32::Service.new }
+      assert_raise(ArgumentError){ Win32::Service.new(@service) }
+      assert_raise(ArgumentError){ Win32::Service.new(@service, 'bogus') }
+   end
+
+   def teardown
+      Win32::Service.delete(@service) if Win32::Service.exists?(@service)
+      sleep 1 while Win32::Service.exists?(@service)
+
+      @notepad = nil
+      @service = nil
+      @status  = nil
+   end
+end

data/test/tc_service_info.rb

@@ -0,0 +1,170 @@
+########################################################################
+# tc_service_info.rb
+#
+# Test case for the Struct::ServiceInfo structure.
+########################################################################
+require 'win32/service'
+require 'test/unit'
+
+class TC_Struct_ServiceInfo < Test::Unit::TestCase
+   def setup
+      @services = Win32::Service.services
+      @service_info = @services[0]
+
+      @error_controls = [
+         'critical',
+         'ignore',
+         'normal',
+         'severe',
+         nil
+      ]
+
+      @start_types = [
+         'auto start',
+         'boot start',
+         'demand start',
+         'disabled',
+         'system start',
+         nil
+      ]
+
+      @types = [
+         'file system driver',
+         'kernel driver',
+         'own process',
+         'share process',
+         'recognizer token',
+         'driver',
+         'win32',
+         'all',
+         'own process, interactive',
+         'share process, interactive',
+         nil
+      ]
+
+      @states = [
+         'continue pending',
+         'pause pending',
+         'paused',
+         'running',
+         'start pending',
+         'stop pending',
+         'stopped',
+         nil
+      ]
+
+      @controls = [ 
+         'netbind change',
+         'param change',
+         'pause continue',
+         'shutdown',
+         'stop',
+         'hardware profile change',
+         'power event',
+         'session change',
+         nil
+      ]
+   end
+
+   def test_service_info_info_service_name
+      assert_respond_to(@service_info, :service_name)
+      assert_kind_of(String, @service_info.service_name)
+   end
+
+   def test_service_info_info_display_name
+      assert_respond_to(@service_info, :display_name)
+      assert_kind_of(String, @service_info.display_name)
+   end
+
+   def test_service_info_info_service_type
+      assert_respond_to(@service_info, :service_type)
+      assert(@types.include?(@service_info.service_type))
+   end
+
+   def test_service_info_current_state
+      assert_respond_to(@service_info, :current_state)
+      assert(@states.include?(@service_info.current_state))
+   end
+
+   def test_service_info_controls_accepted
+      assert_respond_to(@service_info, :controls_accepted)
+      assert(@controls.include?(@service_info.controls_accepted))
+   end
+
+   def test_service_info_win32_exit_code
+      assert_respond_to(@service_info, :win32_exit_code)
+      assert_kind_of(Fixnum, @service_info.win32_exit_code)
+   end
+
+   def test_service_info_service_specific_exit_code
+      assert_respond_to(@service_info, :service_specific_exit_code)
+      assert_kind_of(Fixnum, @service_info.service_specific_exit_code)
+   end
+
+   def test_service_info_check_point
+      assert_respond_to(@service_info, :check_point)
+      assert_kind_of(Fixnum, @service_info.check_point)
+   end
+
+   def test_service_info_wait_hint
+      assert_respond_to(@service_info, :wait_hint)
+      assert_kind_of(Fixnum, @service_info.wait_hint)
+   end
+
+   def test_service_info_binary_path_name
+      assert_respond_to(@service_info, :binary_path_name)
+      assert_kind_of(String, @service_info.binary_path_name)
+   end
+
+   def test_service_info_start_type
+      assert_respond_to(@service_info, :start_type)
+      assert(@start_types.include?(@service_info.start_type))
+   end
+
+   def test_service_info_error_control
+      assert_respond_to(@service_info, :error_control)
+      assert(@error_controls.include?(@service_info.error_control))
+   end
+
+   def test_service_info_load_order_group
+      assert_respond_to(@service_info, :load_order_group)
+      assert_kind_of(String, @service_info.load_order_group)
+   end
+
+   def test_service_info_tag_id
+      assert_respond_to(@service_info, :tag_id)
+      assert_kind_of(Fixnum, @service_info.tag_id)
+   end
+
+   def test_service_info_start_name
+      assert_respond_to(@service_info, :start_name)
+      assert_kind_of(String, @service_info.start_name)
+   end
+
+   def test_service_info_dependencies
+      assert_respond_to(@service_info, :dependencies)
+      assert_kind_of(Array, @service_info.dependencies)
+   end
+
+   def test_service_info_description
+      assert_respond_to(@service_info, :description)
+      assert_kind_of(String, @service_info.description)
+   end
+
+   def test_service_info_interactive
+      assert_respond_to(@service_info, :interactive)
+      assert([true, false].include?(@service_info.interactive))
+   end
+
+   def test_service_info_service_flags
+      assert_respond_to(@service_info, :service_flags)
+      assert([0,1].include?(@service_info.service_flags))
+   end
+
+   def teardown
+      @services = nil
+      @types    = nil
+      @states   = nil
+      @controls = nil
+   end
+end