win32-eventlog 0.5.2 → 0.5.3

data/misc/install_msg.rb

@@ -1,4 +1,4 @@
-##############################################################################
+###############################################################################
 # install_msg.rb
 #
 # This script will create a 'RubyMsg' event source in your registry.  All of
@@ -13,36 +13,34 @@
 # proper directory.
 #
 # You should only run this script *after* you have installed win32-eventlog.
-##############################################################################
-require "rbconfig"
-require "fileutils"
-require "win32/eventlog"
-require "win32/mc"
+###############################################################################
+require 'rbconfig'
+require 'fileutils'
+require 'win32/eventlog'
+require 'win32/mc'
 include Win32
-include Config
 
-prefix  = CONFIG["prefix"]
-msgdir  = prefix + '/rubymsg'
-msgfile = 'rubymsg.mc'
+msg_dir  = File.join(Config::CONFIG['prefix'], 'rubymsg')
+msg_file = 'rubymsg.mc'
 
-Dir.mkdir(msgdir) unless File.exists?(msgdir)
-FileUtils.cp("lib/rubymsg.mc",msgdir)
-Dir.chdir(msgdir)
+Dir.mkdir(msg_dir) unless File.exists?(msg_dir)
+FileUtils.cp('misc/rubymsg.mc', msg_dir)
+Dir.chdir(msg_dir)
 
-m = MC.new(msgfile)
-m.create_all
+mc = Win32::MC.new(msg_file)
+mc.create_all
 
 puts ".dll created"
 
 dll_file = File.expand_path(m.dll_file)
 
 # Change 'Application' to whatever you feel is appropriate
-EventLog.add_event_source(
-   'source'                => "Application",
-   'key_name'              => "RubyMsg",
-   'category_count'        => 3,
-   'event_message_file'    => dll_file,
-   'category_message_file' => dll_file
+Win32::EventLog.add_event_source(
+  :source                => "Application",
+  :key_name              => "RubyMsg",
+  :category_count        => 3,
+  :event_message_file    => dll_file,
+  :category_message_file => dll_file
 )
 
 puts "Event source 'RubyMsg' added to registry"

data/test/test_eventlog.rb

@@ -11,226 +11,309 @@ gem 'test-unit'
 require 'test/unit'
 require 'win32/eventlog'
 require 'socket'
+require 'tmpdir'
 include Win32
 
-class TC_EventLog < Test::Unit::TestCase
-   def self.startup
-      @@hostname = Socket.gethostname      
-   end
+class TC_Win32_EventLog < Test::Unit::TestCase
+  def self.startup
+    @@hostname = Socket.gethostname      
+  end
    
-   def setup
-      @log      = EventLog.new('Application')
-      @logfile  = 'temp.evt'
-      @bakfile  = 'C:\event_log.bak'
-      @records  = []
-      @last     = nil
-   end
+  def setup
+    @log      = EventLog.new('Application')
+    @logfile  = 'temp.evt'
+    @bakfile  = File.join(Dir.tmpdir, 'test_event_log.bak')
+    @records  = []
+    @last     = nil
+  end
  
-   def test_version
-      assert_equal('0.5.2', EventLog::VERSION)
-   end
-   
-   # Use the alias to validate it as well.
-   def test_constructor
-      assert_respond_to(EventLog, :open)
-      assert_nothing_raised{ EventLog.open }
-      assert_nothing_raised{ EventLog.open{ |log| } }
-      assert_nothing_raised{ EventLog.open('System') }
-      assert_nothing_raised{ EventLog.open('System', @@hostname) }
-   end
-   
-   def test_constructor_expected_errors
-      assert_raises(EventLog::Error){ EventLog.new('System', @@hostname, 'foo') }
-      assert_raises(TypeError){ EventLog.open(1) }
-      assert_raises(TypeError){ EventLog.open('System', 1) }
-   end
+  def test_version
+    assert_equal('0.5.3', EventLog::VERSION)
+  end
+
+  test "constructor basic functionality" do
+    assert_respond_to(EventLog, :new)
+    assert_nothing_raised{ EventLog.new }
+  end
+
+  test "constructor accepts a block" do
+    assert_nothing_raised{ EventLog.new{ |log| } }
+  end
+
+  test "constructor accepts a log type" do
+    assert_nothing_raised{ EventLog.new('System') }
+  end
+
+  test "constructor accepts a host name" do
+    assert_nothing_raised{ EventLog.new('System', @@hostname) }
+  end
+
+  test "open is a singleton alias for new" do
+    assert_alias_method(EventLog, :new, :open)
+  end
    
-   def test_constructor_instance_variables
-      assert_nothing_raised{ @log = EventLog.new('Application', @@hostname) }
-      assert_equal(@@hostname, @log.server)
-      assert_equal('Application', @log.source)
-   end
+  test "constructor accepts a maximum of two arguments" do
+    assert_raises(EventLog::Error){ EventLog.new('System', @@hostname, 'foo') }
+  end
+
+  test "arguments to constructor must be strings" do
+    assert_raises(TypeError){ EventLog.open(1) }
+    assert_raises(TypeError){ EventLog.open('System', 1) }
+  end
+
+  test "source accessor method basic functionality" do
+    @log = EventLog.new('Application', @@hostname)
+    assert_respond_to(@log, :source)
+    assert_equal('Application', @log.source)
+  end
+  
+  test "server accessor method basic functionality" do
+    @log = EventLog.new('Application', @@hostname)
+    assert_respond_to(@log, :server)
+    assert_equal(@@hostname, @log.server)
+  end
+
+  test "backup basic functionality" do
+    assert_respond_to(@log, :backup)
+    assert_nothing_raised{ @log.backup(@bakfile) }
+  end
+
+  test "backup works as expected" do
+    assert_nothing_raised{ @log.backup(@bakfile) }
+    assert(File.exists?(@bakfile))
+  end
+
+  test "backup method fails if backup file already exists" do
+    assert_nothing_raised{ @log.backup(@bakfile) }
+    assert_raise(EventLog::Error){ @log.backup(@bakfile) }
+  end
+
+  test "open_backup basic functionality" do
+    assert_respond_to(EventLog, :open_backup)
+  end
    
-   def test_open_backup
-      assert_respond_to(EventLog, :open_backup)
-      assert_nothing_raised{ EventLog.new('Application').backup(@bakfile) }
-      assert_nothing_raised{ @log = EventLog.open_backup(@bakfile) }
-      assert_kind_of(EventLog, @log)
-      assert_nothing_raised{ @log.read{ break } }
-      assert_nothing_raised{ @log.close }
-   end
+  test "open_backup works as expected" do
+    EventLog.new('Application', @@hostname) do |log|
+      log.backup(@bakfile)
+    end
+
+    assert_nothing_raised{ @log = EventLog.open_backup(@bakfile) }
+    assert_kind_of(EventLog, @log)
+  end
+
+  test "it is possible to read and close the backup log file" do
+    EventLog.new('Application', @@hostname) do |log|
+      log.backup(@bakfile)
+    end
+
+    @log = EventLog.open_backup(@bakfile)
+    assert_nothing_raised{ @log.read{ break } }
+    assert_nothing_raised{ @log.close }
+  end
   
-   # Ensure that an Array is returned in non-block form and that none of the
-   # descriptions are nil.
-   # 
-   # The test for descriptions was added as a result of ruby-talk:116528.
-   # Thanks go to Joey Gibson for the spot.  The test for unique record
-   # numbers was added to ensure no dups.
-   # 
-   def test_class_read_verification
-      assert_nothing_raised{ @array = EventLog.read }
-      assert_kind_of(Array, @array)
+  # Ensure that an Array is returned in non-block form and that none of the
+  # descriptions are nil.
+  # 
+  # The test for descriptions was added as a result of ruby-talk:116528.
+  # Thanks go to Joey Gibson for the spot.  The test for unique record
+  # numbers was added to ensure no dups.
+  # 
+  test "singleton read method works as expected" do
+    assert_nothing_raised{ @array = EventLog.read }
+    assert_kind_of(Array, @array)
       
-      record_numbers = []
-      @array.each{ |log|
-         assert_not_nil(log.description)
-         assert_equal(false, record_numbers.include?(log.record_number))
-         record_numbers << log.record_number
-      }
-   end
+    record_numbers = []
+    @array.each{ |log|
+      assert_not_nil(log.description)
+      assert_equal(false, record_numbers.include?(log.record_number))
+      record_numbers << log.record_number
+    }
+  end
   
-   # I've added explicit breaks because an event log could be rather large.
-   # 
-   def test_class_read_basic    
-      assert_nothing_raised{ EventLog.read{ break } }    
-      assert_nothing_raised{ EventLog.read("Application"){ break } }
-      assert_nothing_raised{ EventLog.read("Application", nil){ break } }
-      assert_nothing_raised{ EventLog.read("Application", nil, nil){ break } }
-      assert_nothing_raised{ EventLog.read("Application", nil, nil, 10){ break } } 
-   end  
-   
-   def test_class_read_expected_errors   
-      assert_raises(ArgumentError){
-         EventLog.read("Application", nil, nil, nil, nil){}
-      }
-   end
-   
-   def test_read
-      flags = EventLog::FORWARDS_READ | EventLog::SEQUENTIAL_READ
-      assert_respond_to(@log, :read)
-      assert_nothing_raised{ @log.read{ break } }
-      assert_nothing_raised{ @log.read(flags){ break } }
-      assert_nothing_raised{ @log.read(flags, 500){ break } }
-   end
+  # I've added explicit breaks because an event log could be rather large.
+  # 
+  test "singleton read method does not require any arguments" do
+    assert_nothing_raised{ EventLog.read{ break } }    
+  end
+
+  test "singleton read method accepts a log type" do
+    assert_nothing_raised{ EventLog.read("Application"){ break } }
+  end
+
+  test "singleton read method accepts a server argument" do
+    assert_nothing_raised{ EventLog.read("Application", nil){ break } }
+  end
+
+  test "singleton read method accepts a flags argument" do
+    assert_nothing_raised{ EventLog.read("Application", nil, nil){ break } }
+  end
+
+  test "singleton read method accepts an offset argument" do
+    assert_nothing_raised{ EventLog.read("Application", nil, nil, 10){ break } } 
+  end  
    
-   def test_read_expected_errors
-      flags = EventLog::FORWARDS_READ | EventLog::SEQUENTIAL_READ
-      assert_raises(ArgumentError){ @log.read(flags, 500, 'foo') }
-   end
+  test "singleton read method accepts a maximum of four arguments" do
+    assert_raises(ArgumentError){
+      EventLog.read("Application", nil, nil, nil, nil){}
+    }
+  end
+
+  test "instance method read basic functionality" do   
+    assert_respond_to(@log, :read)
+    assert_nothing_raised{ @log.read{ break } }
+  end
+
+  test "instance method read accepts flags" do
+    flags = EventLog::FORWARDS_READ | EventLog::SEQUENTIAL_READ
+    assert_nothing_raised{ @log.read(flags){ break } }
+  end
+
+  test "instance method read accepts an offset" do
+    assert_nothing_raised{ @log.read(nil, 500){ break } }
+  end
    
-   def test_seek_read
-      flags = EventLog::SEEK_READ | EventLog::FORWARDS_READ
-      assert_nothing_raised{ @last = @log.read[-10].record_number }
-      assert_nothing_raised{
-         @records = EventLog.read(nil, nil, flags, @last)
-      }
-      assert_equal(10, @records.length)
-   end 
+  test "instance method read accepts a maximum of two arguments" do
+    assert_raises(ArgumentError){ @log.read(nil, 500, 'foo') }
+  end
    
-   # This test could fail, since a record number + 10 may not actually exist.
-   def test_seek_read_backwards
-      flags = EventLog::SEEK_READ | EventLog::BACKWARDS_READ
-      assert_nothing_raised{ @last = @log.oldest_record_number + 10 }
-      assert_nothing_raised{ @records = EventLog.read(nil, nil, flags, @last) }
-      assert_equal(11, @records.length)
-   end
+  test "seek_read flag plus forwards_read flag works as expected" do
+    flags = EventLog::SEEK_READ | EventLog::FORWARDS_READ
+    assert_nothing_raised{ @last = @log.read[-10].record_number }
+    assert_nothing_raised{
+      @records = EventLog.read(nil, nil, flags, @last)
+    }
+    assert_equal(10, @records.length)
+  end 
+
+  # This test could fail, since a record number + 10 may not actually exist.
+  test "seek_read flag plus backwards_read flag works as expected" do
+    flags = EventLog::SEEK_READ | EventLog::BACKWARDS_READ
+    assert_nothing_raised{ @last = @log.oldest_record_number + 10 }
+    assert_nothing_raised{ @records = EventLog.read(nil, nil, flags, @last) }
+    assert_equal(11, @records.length)
+  end
    
-   def test_eventlog_struct_is_frozen
-      EventLog.read{ |log| @entry = log; break }
-      assert_true(@entry.frozen?)      
-   end
+  test "the eventlog struct returned by read is frozen" do
+    EventLog.read{ |log| @entry = log; break }
+    assert_true(@entry.frozen?)      
+  end
   
-   def test_server
-      assert_respond_to(@log, :server)
-      assert_raises(NoMethodError){ @log.server = 'foo' }
-   end
-
-   def test_source
-      assert_respond_to(@log, :source)
-      assert_kind_of(String, @log.source)
-      assert_raises(NoMethodError){ @log.source = 'foo' }
-   end
-   
-   def test_file
-      assert_respond_to(@log, :file)
-      assert_nil(@log.file)
-      assert_raises(NoMethodError){ @log.file = 'foo' }
-   end 
-   
-   def test_backup
-      assert_respond_to(@log, :backup)
-      assert_nothing_raised{ @log.backup(@bakfile) }
-      assert(File.exists?(@bakfile))
-      assert_raises(EventLog::Error){ @log.backup(@bakfile) }
-   end
+  test "server method basic functionality" do
+    assert_respond_to(@log, :server)
+    assert_nothing_raised{ @log.server }
+    assert_nil(@log.server)
+  end
+
+  test "server method is readonly" do
+    assert_raises(NoMethodError){ @log.server = 'foo' }
+  end
+
+  test "source method basic functionality" do
+    assert_respond_to(@log, :source)
+    assert_nothing_raised{ @log.source }
+    assert_kind_of(String, @log.source)
+  end
+
+  test "source method is readonly" do
+    assert_raises(NoMethodError){ @log.source = 'foo' }
+  end
+ 
+  test "file method basic functionality" do
+    assert_respond_to(@log, :file)
+    assert_nothing_raised{ @log.file }
+    assert_nil(@log.file)
+  end
+
+  test "file method is readonly" do
+    assert_raises(NoMethodError){ @log.file = 'foo' }
+  end 
    
-   # Since I don't want to actually clear anyone's event log, I can't really
-   # verify that it works.
-   # 
-   def test_clear
-      assert_respond_to(@log, :clear)
-   end
+  # Since I don't want to actually clear anyone's event log, I can't really
+  # verify that it works.
+  test "clear method basic functionality" do
+    assert_respond_to(@log, :clear)
+  end
    
-   def test_full
-      assert_respond_to(@log, :full?)
-      assert_nothing_raised{ @log.full? }
-   end
+  test "full method basic functionality" do
+    assert_respond_to(@log, :full?)
+    assert_nothing_raised{ @log.full? }
+  end
+
+  test "full method returns a boolean" do
+    assert_boolean(@log.full?)
+  end
       
-   def test_close
-      assert_respond_to(@log, :close)
-      assert_nothing_raised{ @log.close }
-   end
-   
-   def test_oldest_record_number
-      assert_respond_to(@log, :oldest_record_number)
-      assert_kind_of(Fixnum, @log.oldest_record_number)
-   end
-   
-   def test_total_records
-      assert_respond_to(@log, :total_records)
-      assert_kind_of(Fixnum, @log.total_records)
-   end
+  test "close method basic functionality" do
+    assert_respond_to(@log, :close)
+    assert_nothing_raised{ @log.close }
+  end
+ 
+  test "oldest_record_number basic functionality" do
+    assert_respond_to(@log, :oldest_record_number)
+    assert_nothing_raised{ @log.oldest_record_number }
+    assert_kind_of(Fixnum, @log.oldest_record_number)
+  end
+ 
+  test "total_records basic functionality" do
+    assert_respond_to(@log, :total_records)
+    assert_nothing_raised{ @log.total_records }
+    assert_kind_of(Fixnum, @log.total_records)
+  end
    
-   # We can't test that this method actually executes properly since it goes
-   # into an endless loop.
-   # 
-   def test_tail
-      assert_respond_to(@log, :tail)
-      assert_raises(EventLog::Error){ @log.tail } # requires block
-   end
+  # We can't test that this method actually executes properly since it goes
+  # into an endless loop.
+  # 
+  test "tail basic functionality" do
+    assert_respond_to(@log, :tail)
+    assert_raises(EventLog::Error){ @log.tail }
+  end
    
-   # We can't test that this method actually executes properly since it goes
-   # into an endless loop.
-   # 
-   def test_notify_change
-      assert_respond_to(@log, :notify_change)
-      assert_raises(EventLog::Error){ @log.notify_change } # requires block
-   end
+  # We can't test that this method actually executes properly since it goes
+  # into an endless loop.
+  # 
+  test "notify_change basic functionality" do
+    assert_respond_to(@log, :notify_change)
+    assert_raises(EventLog::Error){ @log.notify_change }
+  end
    
-   # I can't really do more in depth testing for this method since there
-   # isn't an event source I can reliably and safely write to.
-   # 
-   def test_report_event
-      assert_respond_to(@log, :report_event)
-      assert_respond_to(@log, :write) # alias
-      assert_raises(ArgumentError){ @log.report_event }
-   end
+  # I can't really do more in depth testing for this method since there
+  # isn't an event source I can reliably and safely write to.
+  # 
+  test "report_event basic functionality" do
+    assert_respond_to(@log, :report_event)
+    assert_raises(ArgumentError){ @log.report_event }
+  end
+
+  test "write is an alias for report_event" do
+    assert_respond_to(@log, :write)
+    assert_alias_method(@log, :write, :report_event)
+  end
   
-   def test_read_event_constants
-      assert_not_nil(EventLog::FORWARDS_READ)
-      assert_not_nil(EventLog::BACKWARDS_READ)
-      assert_not_nil(EventLog::SEEK_READ)
-      assert_not_nil(EventLog::SEQUENTIAL_READ)
-   end
-
-   def test_event_type_constants
-      assert_not_nil(EventLog::SUCCESS)
-      assert_not_nil(EventLog::ERROR)
-      assert_not_nil(EventLog::WARN)
-      assert_not_nil(EventLog::INFO)
-      assert_not_nil(EventLog::AUDIT_SUCCESS)
-      assert_not_nil(EventLog::AUDIT_FAILURE)
-   end
+  test "read event constants" do
+    assert_not_nil(EventLog::FORWARDS_READ)
+    assert_not_nil(EventLog::BACKWARDS_READ)
+    assert_not_nil(EventLog::SEEK_READ)
+    assert_not_nil(EventLog::SEQUENTIAL_READ)
+  end
+
+  test "event type constants" do
+    assert_not_nil(EventLog::SUCCESS)
+    assert_not_nil(EventLog::ERROR)
+    assert_not_nil(EventLog::WARN)
+    assert_not_nil(EventLog::INFO)
+    assert_not_nil(EventLog::AUDIT_SUCCESS)
+    assert_not_nil(EventLog::AUDIT_FAILURE)
+  end
    
-   def teardown
-      @log.close rescue nil
-      File.delete(@bakfile) if File.exists?(@bakfile)
-      @logfile  = nil
-      @records  = nil
-      @last     = nil
-   end
+  def teardown
+    @log.close rescue nil
+    File.delete(@bakfile) if File.exists?(@bakfile)
+    @logfile  = nil
+    @records  = nil
+    @last     = nil
+  end
    
-   def self.shutdown
-      @@hostname = nil      
-   end
+  def self.shutdown
+    @@hostname = nil      
+  end
 end