net-ping 1.4.1-x86-mingw32 → 1.5.3-x86-mingw32

data/test/test_net_ping_ldap.rb

@@ -0,0 +1,200 @@
+#################################################################################
+# 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/ldap'
+require 'fakeldap'
+
+class TC_Net_Ping_LDAP < Test::Unit::TestCase
+  class << self
+    def startup
+      @@host = 'localhost'
+      @@port = 2389
+      @@uri = "ldap://#{@@host}:#{@@port}"
+      @@timeout = 30
+      @@cn = 'el.Daper'
+      @@password = 'ldappassword'
+      
+      @@ldap_server = FakeLDAP::Server.new(:port => @@port)
+      @@ldap_server.run_tcpserver
+      @@ldap_server.add_user("cn=#{@@cn},ou=USERS,dc=example,dc=com", @@password)
+    end
+    def shutdown
+      @@ldap_server.stop
+    end
+  end
+  def setup
+    @ldap = Net::Ping::LDAP.new(@@uri, @@timeout)
+    @ldap.username = @@cn
+    @ldap.password = @@password
+    @bogus = 'ldap://blabfoobarurghxxxx.com' # One hopes so
+    @bad  = Net::Ping::LDAP.new(@bogus)
+  end
+
+  def teardown
+    @ldap = nil
+  end
+
+  test 'ping basic functionality' do
+    assert_respond_to(@ldap, :ping)
+    assert_nothing_raised{ @ldap.ping }
+  end
+
+  test 'ping returns a boolean value' do
+    assert_boolean(@ldap.ping?)
+    assert_boolean(@bad.ping?)
+  end
+
+  test 'ping? is an alias for ping' do
+    assert_alias_method(@ldap, :ping?, :ping)
+  end
+
+  test 'pingecho is an alias for ping' do
+    assert_alias_method(@ldap, :pingecho, :ping)
+  end
+
+  test 'ping should succeed for a valid website' do
+    assert_true(@ldap.ping?)
+  end
+
+  test 'ping should fail for an invalid website' do
+    assert_false(@bad.ping?)
+  end
+
+  test 'duration basic functionality' do
+    assert_respond_to(@ldap, :duration)
+    assert_nothing_raised{ @ldap.ping }
+  end
+
+  test 'duration returns a float value on a successful ping' do
+    assert_true(@ldap.ping)
+    assert_kind_of(Float, @ldap.duration)
+  end
+
+  test 'duration is nil on an unsuccessful ping' do
+    assert_false(@bad.ping)
+    assert_nil(@ldap.duration)
+  end
+
+  test "duration is unset if a bad ping follows a good ping" do
+    assert_true{ @ldap.ping }
+    assert_not_nil(@ldap.duration)
+    assert_false(@ldap.ping?(@bogus))
+    assert_nil(@ldap.duration)
+  end
+
+  test 'host attribute basic functionality' do
+    assert_respond_to(@ldap, :host)
+    assert_respond_to(@ldap, :host=)
+    assert_equal(@@host, @ldap.host)
+  end
+  
+  test 'port attribute basic functionality' do
+    assert_respond_to(@ldap, :port)
+    assert_respond_to(@ldap, :port=)
+  end
+
+  test 'port attribute expected value' do
+    assert_equal(@@port, @ldap.port)
+  end
+
+  test 'timeout attribute basic functionality' do
+    assert_respond_to(@ldap, :timeout)
+    assert_respond_to(@ldap, :timeout=)
+  end
+
+  test 'timeout attribute expected values' do
+    assert_equal(@@timeout, @ldap.timeout)
+    assert_equal(5, @bad.timeout)
+  end
+
+  test 'exception attribute basic functionality' do
+    assert_respond_to(@ldap, :exception)
+    assert_nil(@ldap.exception)
+  end
+
+  test 'exception attribute is nil if the ping is successful' do
+    assert_true(@ldap.ping)
+    assert_nil(@ldap.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(@ldap, :warning)
+    assert_nil(@ldap.warning)
+  end
+
+  test 'uri attribute basic functionality' do
+    assert_respond_to(@ldap, :uri)
+    assert_respond_to(@ldap, :uri=)
+  end
+
+  test 'username attribute basic functionality' do
+    assert_respond_to(@ldap, :username)
+    assert_respond_to(@ldap, :username=)
+  end
+
+  test 'password attribute basic functionality' do
+    assert_respond_to(@ldap, :password)
+    assert_respond_to(@ldap, :password=)
+  end
+
+  test 'encryption attribute basic functionality' do
+    assert_respond_to(@ldap, :encryption)
+    assert_respond_to(@ldap, :encryption=)
+  end
+
+  test 'encryption defaults to nil for ldap' do
+    assert_nil(Net::Ping::LDAP.new('ldap://somehost.example.net').encryption)
+  end
+
+  test 'encryption defaults to simple_tls for ldaps' do
+    assert_equal(:simple_tls, Net::Ping::LDAP.new('ldaps://somehost.example.net').encryption)
+  end
+
+  test 'port defaults to 389 for ldap' do
+    assert_equal(389, Net::Ping::LDAP.new('ldap://somehost.example.net').port)
+  end
+
+  test 'port defaults to 636 for ldaps' do
+    assert_equal(636, Net::Ping::LDAP.new('ldaps://somehost.example.net').port)
+  end
+
+  test 'port extracted from uri if provided' do
+    assert_equal(12345, Net::Ping::LDAP.new('ldap://somehost.example.net:12345').port)
+    assert_equal(12345, Net::Ping::LDAP.new('ldaps://somehost.example.net:12345').port)
+  end
+
+  test 'encryption setting is forced to symbol' do
+    @ldap.encryption = 'simple_tls'
+    assert_true( @ldap.encryption.is_a? Symbol )
+    assert_true( @ldap.config[:encryption].is_a? Symbol )
+  end
+
+  test 'username/password set in config auth section' do
+    @ldap.username, @ldap.password = 'fred', 'derf'
+    assert_equal('fred', @ldap.config[:auth][:username] )
+    assert_equal('derf', @ldap.config[:auth][:password] )
+  end
+
+  test 'auth method defaults to simple if username/password set' do
+    @ldap.username, @ldap.password = 'fred', 'derf'
+    assert_equal(:simple, @ldap.config[:auth][:method] )
+  end
+
+  test 'if no username/password then defaults to auth anonymous' do
+    @ldap.username = @ldap.password = nil
+    assert_equal({:method => :anonymous}, @ldap.config[:auth] )
+  end
+
+end

data/test/test_net_ping_tcp.rb

@@ -1,108 +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 = 'localhost'
-    @port = 22
-    @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(22, @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
+#####################################################################
+# 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 = 'localhost'
+    @port = 22
+    @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(22, @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

data/test/test_net_ping_udp.rb

@@ -1,122 +1,122 @@
-########################################################################
-# test_net_ping_udp.rb
-#
-# Test case for the Net::Ping::UDP class. This should be run via the
-# 'test' or 'test:udp' Rake tasks.
-#
-# If someone could provide me a host where a udp ping actually
-# works (with a service check), I would appreciate it. :)
-########################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'net/ping/udp'
-
-class TC_Net_Ping_UDP < Test::Unit::TestCase
-  def setup
-    Net::Ping::UDP.service_check = false
-    @host = '127.0.0.1'
-    @udp  = Net::Ping::UDP.new(@host)
-  end
-
-  test "ping basic functionality" do
-    assert_respond_to(@udp, :ping)
-    assert_nothing_raised{ @udp.ping }
-  end
-
-  test "ping accepts a host as an argument" do
-    assert_nothing_raised{ @udp.ping(@host) }
-  end
-
-  test "ping? is an alias for ping" do
-    assert_respond_to(@udp, :ping?)
-    assert_alias_method(@udp, :ping?, :ping)
-  end
-
-  test "pingecho is an alias for ping" do
-    assert_respond_to(@udp, :pingecho)
-    assert_alias_method(@udp, :pingecho, :ping)
-  end
-
-  test "a successful udp ping returns true" do
-    assert_true(@udp.ping?)
-  end
-
-  test "bind basic functionality" do
-    assert_respond_to(@udp, :bind)
-    assert_nothing_raised{ @udp.bind('127.0.0.1', 80) }
-  end
-   
-  test "duration basic functionality" do
-    assert_nothing_raised{ @udp.ping }
-    assert_respond_to(@udp, :duration)
-    assert_kind_of(Float, @udp.duration)
-  end
-
-  test "host basic functionality" do
-    assert_respond_to(@udp, :host)
-    assert_respond_to(@udp, :host=)
-    assert_equal('127.0.0.1', @udp.host)
-  end
-
-  test "port basic functionality" do
-    assert_respond_to(@udp, :port)
-    assert_respond_to(@udp, :port=)
-    assert_equal(7, @udp.port)
-  end
-
-  test "timeout basic functionality" do
-    assert_respond_to(@udp, :timeout)
-    assert_respond_to(@udp, :timeout=)
-  end
-
-  test "timeout default value is five" do
-    assert_equal(5, @udp.timeout)
-  end
-
-  test "exception basic functionality" do
-    assert_respond_to(@udp, :exception)
-  end
-
-  test "the exception attribute returns nil if the ping is successful" do
-    assert_true(@udp.ping?)
-    assert_nil(@udp.exception)
-  end
-
-  test "the exception attribute is not nil if the ping is unsuccessful" do
-    assert_false(@udp.ping?('www.ruby-lang.org'))
-    assert_not_nil(@udp.exception)
-  end
-
-  test "warning basic functionality" do
-    assert_respond_to(@udp, :warning)
-  end
-
-  test "the warning attribute returns nil if the ping is successful" do
-    assert_true(@udp.ping?)
-    assert_nil(@udp.warning)
-  end
-   
-  test "service_check basic functionality" do
-    assert_respond_to(Net::Ping::UDP, :service_check)
-    assert_respond_to(Net::Ping::UDP, :service_check=)
-  end
-
-  test "service_check attribute has been set to false" do
-    assert_false(Net::Ping::UDP.service_check)
-  end
-   
-  test "service_check getter method does not accept arguments" do
-    assert_raise(ArgumentError){ Net::Ping::UDP.service_check(1) }
-  end
-
-  test "service_check setter method only accepts boolean arguments" do
-    assert_raise(ArgumentError){ Net::Ping::UDP.service_check = 1 }
-  end
-
-  def teardown
-    @host = nil
-    @udp  = nil
-  end
-end
+########################################################################
+# test_net_ping_udp.rb
+#
+# Test case for the Net::Ping::UDP class. This should be run via the
+# 'test' or 'test:udp' Rake tasks.
+#
+# If someone could provide me a host where a udp ping actually
+# works (with a service check), I would appreciate it. :)
+########################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'net/ping/udp'
+
+class TC_Net_Ping_UDP < Test::Unit::TestCase
+  def setup
+    Net::Ping::UDP.service_check = false
+    @host = '127.0.0.1'
+    @udp  = Net::Ping::UDP.new(@host)
+  end
+
+  test "ping basic functionality" do
+    assert_respond_to(@udp, :ping)
+    assert_nothing_raised{ @udp.ping }
+  end
+
+  test "ping accepts a host as an argument" do
+    assert_nothing_raised{ @udp.ping(@host) }
+  end
+
+  test "ping? is an alias for ping" do
+    assert_respond_to(@udp, :ping?)
+    assert_alias_method(@udp, :ping?, :ping)
+  end
+
+  test "pingecho is an alias for ping" do
+    assert_respond_to(@udp, :pingecho)
+    assert_alias_method(@udp, :pingecho, :ping)
+  end
+
+  test "a successful udp ping returns true" do
+    assert_true(@udp.ping?)
+  end
+
+  test "bind basic functionality" do
+    assert_respond_to(@udp, :bind)
+    assert_nothing_raised{ @udp.bind('127.0.0.1', 80) }
+  end
+   
+  test "duration basic functionality" do
+    assert_nothing_raised{ @udp.ping }
+    assert_respond_to(@udp, :duration)
+    assert_kind_of(Float, @udp.duration)
+  end
+
+  test "host basic functionality" do
+    assert_respond_to(@udp, :host)
+    assert_respond_to(@udp, :host=)
+    assert_equal('127.0.0.1', @udp.host)
+  end
+
+  test "port basic functionality" do
+    assert_respond_to(@udp, :port)
+    assert_respond_to(@udp, :port=)
+    assert_equal(7, @udp.port)
+  end
+
+  test "timeout basic functionality" do
+    assert_respond_to(@udp, :timeout)
+    assert_respond_to(@udp, :timeout=)
+  end
+
+  test "timeout default value is five" do
+    assert_equal(5, @udp.timeout)
+  end
+
+  test "exception basic functionality" do
+    assert_respond_to(@udp, :exception)
+  end
+
+  test "the exception attribute returns nil if the ping is successful" do
+    assert_true(@udp.ping?)
+    assert_nil(@udp.exception)
+  end
+
+  test "the exception attribute is not nil if the ping is unsuccessful" do
+    assert_false(@udp.ping?('www.ruby-lang.org'))
+    assert_not_nil(@udp.exception)
+  end
+
+  test "warning basic functionality" do
+    assert_respond_to(@udp, :warning)
+  end
+
+  test "the warning attribute returns nil if the ping is successful" do
+    assert_true(@udp.ping?)
+    assert_nil(@udp.warning)
+  end
+   
+  test "service_check basic functionality" do
+    assert_respond_to(Net::Ping::UDP, :service_check)
+    assert_respond_to(Net::Ping::UDP, :service_check=)
+  end
+
+  test "service_check attribute has been set to false" do
+    assert_false(Net::Ping::UDP.service_check)
+  end
+   
+  test "service_check getter method does not accept arguments" do
+    assert_raise(ArgumentError){ Net::Ping::UDP.service_check(1) }
+  end
+
+  test "service_check setter method only accepts boolean arguments" do
+    assert_raise(ArgumentError){ Net::Ping::UDP.service_check = 1 }
+  end
+
+  def teardown
+    @host = nil
+    @udp  = nil
+  end
+end