test/unit/test_emitter.rb

   1 require "#{File.dirname(__FILE__)}/../test_helper"
   2 require 'tempfile'
   3
   4 class TestEmitter < Test::Unit::TestCase
   5   BEFORE_DELAY = ENV['BEFORE_DELAY'] ? ENV['BEFORE_DELAY'].to_f : 0.5
   6   AFTER_DELAY = ENV['AFTER_DELAY'] ? ENV['AFTER_DELAY'].to_f : 0.5
   7
   8   def test_constants
   9     assert_instance_of Module, LWES, "LWES is not a module"
  10     assert_instance_of Class, LWES::Emitter, "LWES::Emitter is not a class"
  11   end
  12
  13   def lwes_listener(&block)
  14     cmd = "lwes-event-printing-listener" \
  15           " -m #{@options[:address]}" \
  16           " -i #{@options[:iface]}" \
  17           " -p #{@options[:port]}"
  18     out = Tempfile.new("out")
  19     err = Tempfile.new("err")
  20     $stdout.flush
  21     $stderr.flush
  22     pid = fork do
  23       $stdout.reopen(out.path)
  24       $stderr.reopen(err.path)
  25       exec cmd
  26     end
  27     begin
  28       # since everything executes asynchronously and our messaging,
  29       # we need to ensure our listener is ready, then ensure our
  30       # listener has printed something...
  31       # XXX racy
  32       sleep BEFORE_DELAY
  33       yield
  34       sleep AFTER_DELAY
  35     ensure
  36       Process.kill(:TERM, pid)
  37       Process.waitpid2(pid)
  38       assert_equal 0, err.size
  39     end
  40     out
  41   end
  42
  43   def setup
  44     @options = {
  45       :address => ENV["LWES_TEST_ADDRESS"] || "127.0.0.1",
  46       :iface => ENV["LWES_TEST_IFACE"] || "0.0.0.0",
  47       :port => ENV["LWES_TEST_PORT"] ? ENV["LWES_TEST_PORT"].to_i : 12345,
  48       :ttl => 60, # nil for no ttl)
  49     }
  50   end
  51
  52   def test_initialize
  53     assert_instance_of LWES::Emitter, LWES::Emitter.new(@options)
  54   end
  55
  56   def test_initialize_with_heartbeat
  57     heartbeat = @options.merge(:heartbeat => 30)
  58     assert_instance_of LWES::Emitter, LWES::Emitter.new(heartbeat)
  59   end
  60
  61   def test_initialize_no_ttl
  62     no_ttl = @options.dup
  63     no_ttl.delete(:ttl)
  64     assert_instance_of LWES::Emitter, LWES::Emitter.new(no_ttl)
  65   end
  66
  67   def test_initialize_invalid
  68     assert_raises(TypeError) {
  69       LWES::Emitter.new(@options.merge(:address => nil))
  70     }
  71   end
  72
  73   def test_initialize_empty_options
  74     assert_raises(TypeError) { LWES::Emitter.new({}) }
  75   end
  76
  77   def test_emit_invalid
  78     emitter = LWES::Emitter.new(@options)
  79     assert_raises(TypeError) { emitter.emit "Invalid", nil }
  80     assert_raises(ArgumentError) { emitter.emit nil, { :hello => "world" }}
  81   end
  82
  83   def test_emit_empty_hash
  84     emitter = LWES::Emitter.new(@options)
  85     assert_nothing_raised { emitter.emit("Valid", Hash.new) }
  86   end
  87
  88   def test_emit_non_empty_hashes
  89     emitter = LWES::Emitter.new(@options)
  90     out = lwes_listener do
  91       assert_nothing_raised {
  92         emitter.emit("ASDF", { :foo => "FOO", :nr => [ :int16, 50 ] })
  93       }
  94     end
  95     lines = out.readlines
  96     assert_match %r{\AASDF\b}, lines.first
  97     assert ! lines.grep(/foo = FOO;/).empty?
  98     assert ! lines.grep(/nr = 50;/).empty?
  99   end
 100
 101   def test_emit_booleans
 102     emitter = LWES::Emitter.new(@options)
 103     event = { :true => true, :false => false }
 104     out = lwes_listener do
 105       assert_nothing_raised { emitter.emit("BOOLS", event)
 106       }
 107     end
 108     lines = out.readlines
 109     assert_equal 1, lines.grep(/true = true;/).size
 110     assert_equal 1, lines.grep(/false = false;/).size
 111   end
 112
 113   def test_emit_numeric_ranges
 114     check_min_max(:int16, -0x7fff - 1, 0x7fff)
 115     check_min_max(:int32, -0x7fffffff - 1, 0x7fffffff)
 116     check_min_max(:int64, -0x7fffffffffffffff - 1, 0x7fffffffffffffff)
 117     check_min_max(:uint16, 0, 0xffff)
 118     check_min_max(:uint32, 0, 0xffffffff)
 119     check_min_max(:uint64, 0, 0xffffffffffffffff)
 120   end
 121
 122   def check_min_max(type, min, max)
 123     emitter = LWES::Emitter.new(@options)
 124     out = lwes_listener do
 125       assert_raises(RangeError) {
 126         emitter.emit("over", { type => [ type, max + 1] })
 127       }
 128       if (min != 0)
 129         assert_raises(RangeError) {
 130           emitter.emit("under", { type => [ type, min - 1 ] })
 131         }
 132       end
 133       assert_nothing_raised {
 134         emitter.emit("zero", { type => [ type, 0 ] })
 135       }
 136       assert_nothing_raised {
 137         emitter.emit("min", { type => [ type, min ] })
 138       }
 139       assert_nothing_raised {
 140         emitter.emit("max", { type => [ type, max ] })
 141       }
 142     end
 143     lines = out.readlines
 144     assert lines.grep(/\Aover/).empty?
 145     assert lines.grep(/\Aunder/).empty?
 146     assert_equal 1, lines.grep(/\Amax/).size
 147     assert_equal 1, lines.grep(/\Amin/).size
 148     assert_equal 1, lines.grep(/\Azero/).size
 149   end
 150
 151   def test_close
 152     emitter = LWES::Emitter.new(@options)
 153     assert_nil emitter.close
 154   end
 155
 156 end