test/unit/test_emitter.rb

   1 require "#{File.expand_path(File.dirname(__FILE__))}/../test_helper"
   2 require 'ipaddr'
   3
   4 class TestEmitter < Test::Unit::TestCase
   5   def test_constants
   6     assert_instance_of Module, LWES, "LWES is not a module"
   7     assert_instance_of Class, LWES::Emitter, "LWES::Emitter is not a class"
   8   end
   9
  10   def setup
  11     @options = LISTENER_DEFAULTS.dup
  12   end
  13
  14   def test_nil_iface
  15     @options.delete(:iface)
  16     assert_instance_of LWES::Emitter, LWES::Emitter.new(@options)
  17   end
  18
  19   def test_initialize
  20     assert_instance_of LWES::Emitter, LWES::Emitter.new(@options)
  21   end
  22
  23   def test_dup
  24     orig = LWES::Emitter.new(@options)
  25     duped = orig.dup
  26     assert_instance_of LWES::Emitter, duped
  27     assert duped.object_id != orig.object_id
  28   end
  29
  30   def test_clone
  31     orig = LWES::Emitter.new(@options)
  32     cloned = orig.clone
  33     assert_instance_of LWES::Emitter, cloned
  34     assert cloned.object_id != orig.object_id
  35   end
  36
  37   def test_initialize_with_heartbeat
  38     l = LWES::Listener.new(@options)
  39     heartbeat = @options.merge(:heartbeat => 30)
  40     e = LWES::Emitter.new(heartbeat)
  41     assert_instance_of LWES::Emitter, e
  42     assert_nil e.close
  43     assert_instance_of LWES::Event, l.recv
  44     assert_nil l.close
  45   end
  46
  47   def test_initialize_no_ttl
  48     no_ttl = @options.dup
  49     no_ttl.delete(:ttl)
  50     assert_instance_of LWES::Emitter, LWES::Emitter.new(no_ttl)
  51   end
  52
  53   def test_initialize_invalid
  54     assert_raises(TypeError) {
  55       LWES::Emitter.new(@options.merge(:address => nil))
  56     }
  57   end
  58
  59   def test_initialize_empty_options
  60     assert_raises(TypeError) { LWES::Emitter.new({}) }
  61   end
  62
  63   def test_emit_invalid
  64     emitter = LWES::Emitter.new(@options)
  65     assert_raises(TypeError) { emitter.emit "Invalid", nil }
  66     assert_raises(ArgumentError) { emitter.emit nil, { :hello => "world" }}
  67   end
  68
  69   def test_emit_empty_hash
  70     emitter = LWES::Emitter.new(@options)
  71     assert_nothing_raised { emitter.emit("Valid", Hash.new) }
  72   end
  73
  74   def test_emit_non_empty_hashes
  75     emitter = LWES::Emitter.new(@options)
  76     out = lwes_listener do
  77       assert_nothing_raised {
  78         emitter.emit("ASDF", { :foo => "FOO", :nr => [ :int16, 50 ] })
  79       }
  80     end
  81     lines = out.readlines
  82     assert_match %r{\AASDF\b}, lines.first
  83     assert ! lines.grep(/foo = FOO;/).empty?
  84     assert ! lines.grep(/nr = 50;/).empty?
  85   end
  86
  87   def test_emit_ip_addr_string
  88     emitter = LWES::Emitter.new(@options)
  89     event = { :string_ip => [ :ip_addr, "192.168.1.1" ] }
  90     out = lwes_listener do
  91       assert_nothing_raised { emitter.emit("STRING_IP", event) }
  92     end
  93     lines = out.readlines
  94     assert_equal 1, lines.grep(/string_ip = 192.168.1.1/).size
  95   end
  96
  97   def test_emit_ip_addr_int
  98     emitter = LWES::Emitter.new(@options)
  99     event = { :int_ip => [ :ip_addr, IPAddr.new("192.168.1.1").to_i ] }
 100     out = lwes_listener do
 101       assert_nothing_raised { emitter.emit("INT_IP", event) }
 102     end
 103     lines = out.readlines
 104     assert_equal 1, lines.grep(/int_ip = 192.168.1.1/).size
 105   end
 106
 107   def test_emit_junk
 108     emitter = LWES::Emitter.new(@options)
 109     assert_raises(ArgumentError) { emitter.emit("JUNK", :junk => %r{junk}) }
 110   end
 111
 112   def test_emit_booleans
 113     emitter = LWES::Emitter.new(@options)
 114     event = { :true => true, :false => false }
 115     out = lwes_listener do
 116       assert_nothing_raised { emitter.emit("BOOLS", event)
 117       }
 118     end
 119     lines = out.readlines
 120     assert_equal 1, lines.grep(/true = true;/).size
 121     assert_equal 1, lines.grep(/false = false;/).size
 122   end
 123
 124   def test_emit_numeric_ranges
 125     check_min_max(:int16, -0x7fff - 1, 0x7fff)
 126     check_min_max(:int32, -0x7fffffff - 1, 0x7fffffff)
 127     check_min_max(:int64, -0x7fffffffffffffff - 1, 0x7fffffffffffffff)
 128     check_min_max(:uint16, 0, 0xffff)
 129     check_min_max(:uint32, 0, 0xffffffff)
 130     check_min_max(:uint64, 0, 0xffffffffffffffff)
 131     huge = 0xffffffffffffffffffffffffffffffff
 132     tiny = -0xffffffffffffffffffffffffffffffff
 133     [ :int16, :int32, :int64, :uint16, :uint32, :uint64 ].each do |type|
 134       emitter = LWES::Emitter.new(@options)
 135       assert_raises(RangeError) {
 136         emitter.emit("way over", { type => [ type, huge ] })
 137       }
 138       assert_raises(RangeError) {
 139         emitter.emit("way under", { type => [ type, tiny ] })
 140       }
 141     end
 142   end
 143
 144   def check_min_max(type, min, max)
 145     emitter = LWES::Emitter.new(@options)
 146     out = lwes_listener do
 147       assert_raises(RangeError) {
 148         emitter.emit("over", { type => [ type, max + 1] })
 149       }
 150       assert_raises(RangeError, "type=#{type} min=#{min}") {
 151         emitter.emit("under", { type => [ type, min - 1 ] })
 152       }
 153       assert_nothing_raised {
 154         emitter.emit("zero", { type => [ type, 0 ] })
 155       }
 156       assert_nothing_raised {
 157         emitter.emit("min", { type => [ type, min ] })
 158       }
 159       assert_nothing_raised {
 160         emitter.emit("max", { type => [ type, max ] })
 161       }
 162     end
 163     lines = out.readlines
 164     assert lines.grep(/\Aover/).empty?
 165     assert lines.grep(/\Aunder/).empty?
 166     assert_equal 1, lines.grep(/\Amax/).size
 167     assert_equal 1, lines.grep(/\Amin/).size
 168     assert_equal 1, lines.grep(/\Azero/).size
 169   end
 170
 171   def test_emit_uint64
 172     emitter = LWES::Emitter.new(@options)
 173     assert_nothing_raised {
 174       emitter.emit("Foo", { :uint64 => [ :uint64, 10_000_000_000 ] })
 175     }
 176   end
 177
 178   def test_emit_enc_sym
 179     emitter = LWES::Emitter.new(@options)
 180     tmp = {
 181       :enc => 1,
 182       :a => "b",
 183       :c => "d",
 184     }
 185     out = lwes_listener do
 186       assert_nothing_raised { emitter.emit("EncTest", tmp) }
 187     end
 188     lines = out.readlines
 189     assert_equal 1, lines.grep(/\A\tenc = 1;\n\z/).size
 190     assert_equal 1, lines.grep(/\A\ta = b;\n\z/).size
 191     assert_equal 1, lines.grep(/\A\tc = d;\n\z/).size
 192   end
 193
 194   def test_emit_enc_str
 195     emitter = LWES::Emitter.new(@options)
 196     tmp = {
 197       :enc => 1,
 198       :a => "b",
 199       :c => "d",
 200     }
 201     out = lwes_listener do
 202       assert_nothing_raised { emitter.emit("EncTest", tmp) }
 203     end
 204     lines = out.readlines
 205     assert_equal 1, lines.grep(/\A\tenc = 1;\n\z/).size
 206     assert_equal 1, lines.grep(/\A\ta = b;\n\z/).size
 207     assert_equal 1, lines.grep(/\A\tc = d;\n\z/).size
 208   end
 209
 210   def test_emit_huge_event
 211     emitter = LWES::Emitter.new(@options)
 212     tmp = {
 213       :a => ("b" * (1024 * 1024)),
 214     }
 215     assert_raises(ArgumentError) do
 216       emitter.emit("BigTest", tmp)
 217     end
 218   end
 219
 220   def test_close
 221     emitter = LWES::Emitter.new(@options)
 222     assert_nil emitter.close
 223   end
 224
 225 end