net-ping 1.3.3-x86-mingw32

data/test/test_net_ping.rb

@@ -0,0 +1,26 @@
+######################################################################
+# test_net_ping.rb
+#
+# Test suite for all the Ping subclasses. Note that the Ping::ICMP
+# class test won't be run unless this is run as a privileged process.
+######################################################################
+require 'test_net_ping_external'
+require 'test_net_ping_http'
+require 'test_net_ping_tcp'
+require 'test_net_ping_udp'
+
+if Process.euid == 0
+  require 'test_net_ping_icmp'
+end
+
+if Config::CONFIG['host_os'] =~ /mswin|win32|dos|cygwin|mingw/i &&
+  RUBY_PLATFORM != 'java'
+then
+  require 'test_net_ping_wmi'
+end
+
+class TC_Net_Ping < Test::Unit::TestCase
+  def test_net_ping_version
+    assert_equal('1.3.3', Net::Ping::VERSION)
+  end
+end

data/test/test_net_ping_external.rb

@@ -0,0 +1,87 @@
+#########################################################################
+# test_net_ping_external.rb
+#
+# Test case for the Net::PingExternal class. Run this via the 'test' or
+# 'test:external' rake task.
+#########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'net/ping/external'
+
+class TC_Net_Ping_External < Test::Unit::TestCase
+  def setup
+    @host  = 'www.ruby-lang.org'
+    @bogus = 'foo.bar.baz'
+    @pe    = Net::Ping::External.new(@host)
+    @bad   = Net::Ping::External.new(@bogus)
+  end
+
+  def test_ping
+    assert_respond_to(@pe, :ping)
+    assert_nothing_raised{ @pe.ping }
+    assert_nothing_raised{ @pe.ping(@host) }
+  end
+
+  def test_ping_aliases
+    assert_respond_to(@pe, :ping?)
+    assert_respond_to(@pe, :pingecho)
+    assert_nothing_raised{ @pe.ping? }
+    assert_nothing_raised{ @pe.ping?(@host) }
+    assert_nothing_raised{ @pe.pingecho }
+    assert_nothing_raised{ @pe.pingecho(@host) }
+  end
+
+  def test_good_ping     
+    assert_equal(true, @pe.ping?)
+  end
+
+  def test_bad_ping
+    assert_equal(false, @bad.ping?)
+    assert_equal(false, @bad.exception.nil?, "Bad exception data")
+  end
+
+  def test_duration
+    assert_nothing_raised{ @pe.ping }
+    assert_respond_to(@pe, :duration)
+    assert_kind_of(Float, @pe.duration)
+  end
+
+  def test_host
+    assert_respond_to(@pe, :host)
+    assert_respond_to(@pe, :host=)
+    assert_equal('www.ruby-lang.org', @pe.host)
+  end
+
+  def test_port
+    assert_respond_to(@pe, :port)
+    assert_respond_to(@pe, :port=)
+    assert_equal(7, @pe.port)
+  end
+
+  def test_timeout
+    assert_respond_to(@pe, :timeout)
+    assert_respond_to(@pe, :timeout=)
+    assert_equal(5, @pe.timeout)
+  end
+
+  def test_exception
+    assert_respond_to(@pe, :exception)
+    assert_nothing_raised{ @pe.ping }
+    assert_nothing_raised{ @bad.ping }
+    assert_nil(@pe.exception)
+    assert_not_nil(@bad.exception)
+  end
+
+  def test_warning
+    assert_respond_to(@pe, :warning)
+  end
+
+  def teardown
+    @host  = nil
+    @bogus = nil
+    @pe    = nil
+    @bad   = nil
+  end
+end

data/test/test_net_ping_http.rb

@@ -0,0 +1,115 @@
+#################################################################################
+# test_net_ping_http.rb
+#
+# Test case for the Net::PingHTTP class. This should be run via the 'test' or
+# 'test:http' Rake task.
+#################################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'net/ping/http'
+
+class TC_Net_Ping_HTTP < Test::Unit::TestCase
+  def setup
+    @uri  = 'http://www.google.com/index.html'
+    @http = Net::Ping::HTTP.new(@uri, 80, 30)      
+    @bad  = Net::Ping::HTTP.new('http://www.blabfoobarurghxxxx.com') # One hopes not
+  end
+
+  test 'ping basic functionality' do
+    assert_respond_to(@http, :ping)
+    assert_nothing_raised{ @http.ping }
+  end
+
+  test 'ping returns a boolean value' do
+    assert_boolean(@http.ping?)
+    assert_boolean(@bad.ping?)
+  end
+
+  test 'ping? is an alias for ping' do
+    assert_alias_method(@http, :ping?, :ping)
+  end
+
+  test 'pingecho is an alias for ping' do
+    assert_alias_method(@http, :pingecho, :ping)
+  end
+
+  test 'ping should succeed for a valid website' do
+    assert_true(@http.ping?)
+  end
+
+  test 'ping should fail for an invalid website' do
+    assert_false(@bad.ping?)
+  end
+
+  test 'duration basic functionality' do
+    assert_respond_to(@http, :duration)
+    assert_nothing_raised{ @http.ping }
+  end
+
+  test 'duration returns a float value on a successful ping' do
+    assert_true(@http.ping)
+    assert_kind_of(Float, @http.duration)
+  end
+
+  test 'duration is nil on an unsuccessful ping' do
+    assert_false(@bad.ping)
+    assert_nil(@http.duration)
+  end
+
+  test 'host attribute basic functionality' do
+    assert_respond_to(@http, :host)
+    assert_respond_to(@http, :host=)
+    assert_equal('http://www.google.com/index.html', @http.host)
+  end
+
+  test 'uri is an alias for host' do
+    assert_alias_method(@http, :uri, :host)
+    assert_alias_method(@http, :uri=, :host=)
+  end
+
+  test 'port attribute basic functionality' do
+    assert_respond_to(@http, :port)
+    assert_respond_to(@http, :port=)
+  end
+
+  test 'port attribute expected value' do
+    assert_equal(80, @http.port)
+  end
+
+  test 'timeout attribute basic functionality' do
+    assert_respond_to(@http, :timeout)
+    assert_respond_to(@http, :timeout=)
+  end
+
+  test 'timeout attribute expected values' do
+    assert_equal(30, @http.timeout)
+    assert_equal(5, @bad.timeout)
+  end
+
+  test 'exception attribute basic functionality' do
+    assert_respond_to(@http, :exception)
+    assert_nil(@http.exception)
+  end
+
+  test 'exception attribute is nil if the ping is successful' do
+    assert_true(@http.ping)
+    assert_nil(@http.exception)
+  end
+
+  test 'exception attribute is not nil if the ping is unsuccessful' do
+    assert_false(@bad.ping)
+    assert_not_nil(@bad.exception)
+  end
+
+  test 'warning attribute basic functionality' do
+    assert_respond_to(@http, :warning)
+    assert_nil(@http.warning)
+  end
+
+  def teardown
+    @uri  = nil
+    @http = nil
+  end
+end

data/test/test_net_ping_icmp.rb

@@ -0,0 +1,126 @@
+#######################################################################
+# test_net_ping_icmp.rb
+#
+# Test case for the Net::PingICMP class.  You must run this test case
+# with root privileges on UNIX systems. This should be run via the
+# 'test' or 'test:icmp' Rake task.
+#######################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'net/ping/icmp'
+include Net
+
+unless Process.euid == 0
+   raise "The test:icmp task must be run with root privileges"
+end
+
+class TC_PingICMP < Test::Unit::TestCase
+   def self.startup
+      @@one_click = Config::CONFIG['host_os'] == 'mswin32'
+   end
+   
+   def setup
+      @host = "www.ruby-lang.org"
+      @icmp = Ping::ICMP.new(@host)
+   end
+
+   def test_ping
+      assert_respond_to(@icmp, :ping)
+      
+      omit_if(@@one_click, 'Unreliable socket library')
+
+      assert_nothing_raised{ @icmp.ping }
+      assert_nothing_raised{ @icmp.ping(@host) }
+   end
+
+   def test_ping_aliases_basic
+      assert_respond_to(@icmp, :ping?)
+      assert_respond_to(@icmp, :pingecho)
+
+      omit_if(@@one_click, 'Unreliable socket library')
+
+      assert_nothing_raised{ @icmp.ping? }
+      assert_nothing_raised{ @icmp.ping?(@host) }
+   end
+
+   def test_ping_returns_boolean
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_boolean(@icmp.pingecho)
+      assert_boolean(@icmp.pingecho(@host))
+   end
+   
+   def test_ping_expected_failure
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_false(Ping::ICMP.new('bogus').ping?)
+      assert_false(Ping::ICMP.new('http://www.asdfhjklasdfhlkj.com').ping?)      
+   end
+
+   def test_bind
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_respond_to(@icmp, :bind)
+      assert_nothing_raised{ @icmp.bind(Socket.gethostname) }
+      assert_nothing_raised{ @icmp.bind(Socket.gethostname, 80) }
+   end
+
+   def test_duration
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_nothing_raised{ @icmp.ping }
+      assert_respond_to(@icmp, :duration)
+      assert_kind_of(Float, @icmp.duration)
+   end
+
+   def test_host
+      assert_respond_to(@icmp, :host)
+      assert_respond_to(@icmp, :host=)
+      assert_equal('www.ruby-lang.org', @icmp.host)
+   end
+
+   def test_port
+      assert_respond_to(@icmp, :port)
+      assert_equal(nil, @icmp.port)
+   end
+
+   def test_timeout
+      assert_respond_to(@icmp, :timeout)
+      assert_respond_to(@icmp, :timeout=)
+      assert_equal(5, @icmp.timeout)
+   end
+
+   def test_exception
+      assert_respond_to(@icmp, :exception)
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_nothing_raised{ @icmp.ping }
+      assert_nil(@icmp.exception)
+   end
+
+   def test_warning
+      assert_respond_to(@icmp, :warning)
+   end
+
+   def test_data_size_get
+      assert_respond_to(@icmp, :data_size)
+      assert_equal(56, @icmp.data_size)
+   end
+
+   def test_data_size_set
+      assert_respond_to(@icmp, :data_size=)
+      assert_nothing_raised{ @icmp.data_size = 22 }
+   end
+
+   def test_odd_data_size_ok
+      assert_nothing_raised{ @icmp.data_size = 57 }
+      omit_if(@@one_click, 'Unreliable socket library')
+      assert_boolean(@icmp.ping)
+   end
+
+   def teardown
+      @host = nil
+      @icmp = nil
+   end
+   
+   def self.shutdown
+      @@one_click = nil      
+   end
+end

data/test/test_net_ping_tcp.rb

@@ -0,0 +1,108 @@
+#####################################################################
+# test_net_ping_tcp.rb
+#
+# Test case for the Net::PingTCP class. This test should be run via
+# the 'test' or 'test:tcp' Rake task.
+#####################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'net/ping/tcp'
+include Net
+
+class TC_PingTCP < Test::Unit::TestCase
+  def setup
+    @host = 'www.ruby-lang.org'
+    @port = 'ftp'
+    @tcp  = Ping::TCP.new(@host, @port)
+  end
+
+  def test_ping
+    assert_respond_to(@tcp, :ping)
+    assert_nothing_raised{ @tcp.ping }
+    assert_nothing_raised{ @tcp.ping(@host) }
+  end
+
+  def test_ping_aliases
+    assert_respond_to(@tcp, :ping?)
+    assert_respond_to(@tcp, :pingecho)
+    assert_nothing_raised{ @tcp.ping? }
+    assert_nothing_raised{ @tcp.ping?(@host) }
+    assert_nothing_raised{ @tcp.pingecho }
+    assert_nothing_raised{ @tcp.pingecho(@host) }
+  end
+
+  def test_ping_service_check_false
+    msg = "+this test may fail depending on your network environment+"
+    Ping::TCP.service_check = false
+    @tcp = Ping::TCP.new('localhost')
+    assert_false(@tcp.ping?, msg)
+    assert_false(@tcp.exception.nil?, "Bad exception data")
+  end
+
+  def test_ping_service_check_true
+    msg = "+this test may fail depending on your network environment+"
+    Ping::TCP.service_check = true
+    assert_true(@tcp.ping?, msg)
+  end
+   
+  def test_service_check
+    assert_respond_to(Ping::TCP, :service_check)
+    assert_respond_to(Ping::TCP, :service_check=)    
+  end
+   
+  # These will be removed eventually
+  def test_service_check_aliases
+    assert_respond_to(Ping::TCP, :econnrefused)
+    assert_respond_to(Ping::TCP, :econnrefused=)
+    assert_respond_to(Ping::TCP, :ecr)
+    assert_respond_to(Ping::TCP, :ecr=)     
+  end
+   
+  def test_service_check_expected_errors
+    assert_raises(ArgumentError){ Ping::TCP.service_check = "blah" }
+  end
+   
+  # If the ping failed, the duration will be nil
+  def test_duration
+    assert_nothing_raised{ @tcp.ping }
+    assert_respond_to(@tcp, :duration)
+    omit_if(@tcp.duration.nil?, 'ping failed, skipping')
+    assert_kind_of(Float, @tcp.duration)
+  end
+
+  def test_host
+    assert_respond_to(@tcp, :host)
+    assert_respond_to(@tcp, :host=)
+    assert_equal(@host, @tcp.host)
+  end
+
+  def test_port
+    assert_respond_to(@tcp, :port)
+    assert_respond_to(@tcp, :port=)
+    assert_equal('ftp', @tcp.port)
+  end
+
+  def test_timeout
+    assert_respond_to(@tcp, :timeout)
+    assert_respond_to(@tcp, :timeout=)
+    assert_equal(5, @tcp.timeout)
+  end
+
+  def test_exception
+    msg = "+this test may fail depending on your network environment+"
+    assert_respond_to(@tcp, :exception)
+    assert_nothing_raised{ @tcp.ping }
+    assert_nil(@tcp.exception, msg)
+  end
+
+  def test_warning
+    assert_respond_to(@tcp, :warning)
+  end
+
+  def teardown
+    @host = nil
+    @tcp  = nil
+  end
+end