igp 0.0.2 → 1.1.0

data/lib/net/ping/ldap.rb

@@ -0,0 +1,105 @@
+require 'net/ping'
+require 'net/ldap'
+require 'uri'
+
+# The Net module serves as a namespace only.
+module Net
+  # The Ping::LDAP class encapsulates methods for LDAP pings.
+  class Ping::LDAP < Ping
+    # uri contains the URI object for the request
+    #
+    attr_accessor :uri
+
+    # username and password may be set for ping using
+    # an authenticated LDAP bind
+    #
+    attr_accessor :username
+    attr_accessor :password
+
+    # set/get the encryption method. By default nil,
+    # but may be set to :simple_tls
+    #
+    attr_reader :encryption
+
+    def encryption=(value)
+      @encryption = value.is_a?(Symbol) ? value : value.to_sym
+    end
+
+    # Creates and returns a new Ping::LDAP object.
+    # The default +timeout+ is 5 seconds.
+    #
+    # +uri+ string is expected to be a full URI with scheme (ldap/ldaps)
+    # and optionally the port (else default port is assumed) e.g.
+    #   ldap://my.ldap.host.com
+    #   ldap://my.ldap.host.com:1389
+    #   ldaps://my.ldap.host.com
+    #   ldaps://my.ldap.host.com:6636
+    #
+    # If a plain hostname is provided as the +uri+, a default port of 389 is assumed
+    #
+    def initialize(uri = nil, timeout = 5)
+      host, port = decode_uri(uri)
+      super(host, port, timeout)
+    end
+
+    # method used to decode uri string
+    #
+    def decode_uri(value)
+      @uri = URI.parse(value)
+      if uri.scheme =~ /ldap/
+        p = @port = uri.port
+        h = @host = uri.host
+        @encryption = uri.scheme == 'ldaps' ? :simple_tls : nil
+      else
+        h = value
+        p = 389
+      end
+      [h, p]
+    end
+
+    # constructs the LDAP configuration structure
+    #
+    def config
+      {
+        host: uri.host,
+        port: uri.port,
+        encryption: encryption
+      }.merge(
+        if username && password
+          { auth: { method: :simple, username: username, password: password } }
+        else
+          { auth: { method: :anonymous } }
+        end
+      )
+    end
+
+    # perform ping, optionally providing the ping destination uri
+    #
+    def ping(host = nil)
+      decode_uri(host) if host
+      super(@host)
+
+      bool = false
+
+      start_time = Time.now
+
+      begin
+        Timeout.timeout(@timeout) do
+          Net::LDAP.new(config).bind
+        end
+      rescue StandardError => e
+        @exception = e.message
+      else
+        bool = true
+      end
+
+      # There is no duration if the ping failed
+      @duration = Time.now - start_time if bool
+
+      bool
+    end
+
+    alias ping? ping
+    alias pingecho ping
+  end
+end

data/spec/base_spec.rb

@@ -2,65 +2,64 @@ require 'spec_helper'
 require 'getoptions'
 
 describe Igp::Base do
-
-  describe "base initialization without options" do
-    it "should not set ping_handler" do
-      subject.ping_handler.should be_nil
+  describe 'base initialization without options' do
+    it 'should not set ping_handler' do
+      expect(subject.ping_handler).to be_nil
     end
-    it "should not set limit" do
-      subject.limit.should be_nil
+    it 'should not set limit' do
+      expect(subject.limit).to be_nil
     end
-    it "should default interval to 5 sec" do
-      subject.interval.should eql(5)
+    it 'should default interval to 5 sec' do
+      expect(subject.interval).to eql(5)
     end
   end
-  
-  describe "ping_handler configuration" do
-    it "should be Net::Ping::External for :icmp" do
-      options = { :type => :icmp, :host => 'localhost', :port => nil}
+
+  describe 'ping_handler configuration' do
+    it 'should be Net::Ping::External for :icmp' do
+      options = { type: :icmp, host: 'localhost', port: nil }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::External)
+      expect(base.ping_handler).to be_a(Net::Ping::External)
     end
-    it "should be Net::Ping::UDP for :tcp" do
-      options = { :type => :udp, :host => 'localhost', :port => 22}
+    it 'should be Net::Ping::UDP for :tcp' do
+      options = { type: :udp, host: 'localhost', port: 22 }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::UDP)
+      expect(base.ping_handler).to be_a(Net::Ping::UDP)
     end
-    it "should be Net::Ping::TCP for :tcp" do
-      options = { :type => :tcp, :host => 'localhost', :port => 22}
+    it 'should be Net::Ping::TCP for :tcp' do
+      options = { type: :tcp, host: 'localhost', port: 22 }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::TCP)
+      expect(base.ping_handler).to be_a(Net::Ping::TCP)
     end
-    it "should be Net::Ping::HTTP for :http" do
-      options = { :type => :http, :url => 'http://localhost'}
+    it 'should be Net::Ping::HTTP for :http' do
+      options = { type: :http, url: 'http://localhost' }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::HTTP)
+      expect(base.ping_handler).to be_a(Net::Ping::HTTP)
     end
-    it "should be Net::Ping::HTTP for :https" do
-      options = { :type => :https, :url => 'https://localhost'}
+    it 'should be Net::Ping::HTTP for :https' do
+      options = { type: :https, url: 'https://localhost' }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::HTTP)
+      expect(base.ping_handler).to be_a(Net::Ping::HTTP)
     end
-    it "should be Net::Ping::LDAP for :ldap" do
-      options = { :type => :ldap, :url => 'ldap://localhost'}
+    it 'should be Net::Ping::LDAP for :ldap' do
+      options = { type: :ldap, url: 'ldap://localhost' }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::LDAP)
+      expect(base.ping_handler).to be_a(Net::Ping::LDAP)
     end
-    it "should be Net::Ping::LDAP for :ldaps" do
-      options = { :type => :ldaps, :url => 'ldaps://localhost'}
+    it 'should be Net::Ping::LDAP for :ldaps' do
+      options = { type: :ldaps, url: 'ldaps://localhost' }
       base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::LDAP)
+      expect(base.ping_handler).to be_a(Net::Ping::LDAP)
     end
   end
 
-  describe "#run" do
+  describe '#run' do
     before do
-      @good = Igp::Base.new({ :type => :icmp, :host => 'localhost', :port => nil, :limit => 1})
+      @good = Igp::Base.new({ type: :icmp, host: 'localhost', port: nil, limit: 1 })
     end
-    it "should print header and log a ping result" do
-      @good.formatter.should_receive(:header)
-      @good.formatter.should_receive(:log)
-      capture(:stdout,:stderr){ @good.run }
+    it 'should print header and log a ping result' do
+      expect(@good.formatter).to receive(:header)
+      expect(@good.formatter).to receive(:log)
+      capture(:stdout, :stderr) { @good.run }
     end
   end
-end
+end

data/spec/format_spec.rb

@@ -2,47 +2,45 @@ require 'spec_helper'
 require 'getoptions'
 
 describe Igp::Base::Format do
-
   describe '#duration' do
-    it "should return nil for nil duration" do
-      subject.duration(nil).should be_nil
+    it 'should return nil for nil duration' do
+      expect(subject.duration(nil)).to be_nil
     end
-    it "should return string to 6 decimal places for non-nil duration" do
+    it 'should return string to 6 decimal places for non-nil duration' do
       result = subject.duration(1.0)
-      result.should match(/^\d+\.\d{6}$/)
-      result.to_f.should eql(1.0)
+      expect(result).to match(/^\d+\.\d{6}$/)
+      expect(result.to_f).to eql(1.0)
     end
-    it "should handle integer parameter" do
+    it 'should handle integer parameter' do
       result = subject.duration(1)
-      result.should match(/^\d+\.\d{6}$/)
-      result.to_f.should eql(1.0)
+      expect(result).to match(/^\d+\.\d{6}$/)
+      expect(result.to_f).to eql(1.0)
     end
   end
 
   describe '#header' do
-    it "should output a blank line for nil parameters" do
-      result = capture(:stderr){ subject.header(nil) }
-      result.should eql("\n")
+    it 'should output a blank line for nil parameters' do
+      result = capture(:stderr) { subject.header(nil) }
+      expect(result).to eql("\n")
     end
-    it "should convert an arbitrary array of strings and numbers to a space-delimited output to stderr" do
-      result = capture(:stderr){ subject.header("string",1.0,"another string",2.0) }
-      result.should eql("string 1.0 another string 2.0\n")
+    it 'should convert an arbitrary array of strings and numbers to a space-delimited output to stderr' do
+      result = capture(:stderr) { subject.header('string', 1.0, 'another string', 2.0) }
+      expect(result).to eql("string 1.0 another string 2.0\n")
     end
   end
 
   describe '#log' do
-    it "should output time only for nil parameters" do
-      result = capture(:stdout){ subject.log(nil) }
-      result.should match(/^.+Z,$/)
+    it 'should output time only for nil parameters' do
+      result = capture(:stdout) { subject.log(nil) }
+      expect(result).to match(/^.+Z,$/)
     end
-    it "should log successful message (boolean,float,nil) to stdout" do
-      result = capture(:stdout){ subject.log(true,1.0,nil) }
-      result.should match(/^.+Z,true,1.0,$/)
+    it 'should log successful message (boolean,float,nil) to stdout' do
+      result = capture(:stdout) { subject.log(true, 1.0, nil) }
+      expect(result).to match(/^.+Z,true,1.0,$/)
     end
-    it "should log unsuccessful message (boolean,nil,string) to stdout" do
-      result = capture(:stdout){ subject.log(false,nil,"message") }
-      result.should match(/^.+Z,false,,message$/)
+    it 'should log unsuccessful message (boolean,nil,string) to stdout' do
+      result = capture(:stdout) { subject.log(false, nil, 'message') }
+      expect(result).to match(/^.+Z,false,,message$/)
     end
   end
-
-end
+end

data/spec/net/ping/ldap_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'fakeldap'
+
+describe Net::Ping::LDAP do
+  before :all do
+    @ldap_server = FakeLDAP::Server.new(port: 2389)
+    @ldap_server.run_tcpserver
+    @ldap_server.add_user('cn=el.Daper,ou=USERS,dc=example,dc=com', 'ldappassword')
+  end
+
+  after :all do
+    @ldap_server.stop
+  end
+
+  context 'when valid ldap url' do
+    let(:timeout) { 30 }
+    let(:cn) { 'el.Daper' }
+    let(:password) { 'ldappassword' }
+    let(:uri) { 'ldap://localhost:2389' }
+    subject(:ldap) do
+      ldap = Net::Ping::LDAP.new(uri, timeout)
+      ldap.username = cn
+      ldap.password = password
+      ldap
+    end
+
+    describe '#ping' do
+      subject { ldap.ping }
+      it 'ping basic functionality' do
+        expect { subject }.to_not raise_error
+        expect(subject).to eql(true)
+      end
+    end
+    describe '#ping?' do
+      subject { ldap.ping? }
+      it 'returns a boolean' do
+        expect(subject).to eql(true)
+      end
+    end
+    describe '#pingecho' do
+      subject { ldap.pingecho }
+      it 'returns a boolean' do
+        expect(subject).to eql(true)
+      end
+    end
+    describe '#duration' do
+      subject { ldap.duration }
+      before  { ldap.ping }
+      it 'returns a float' do
+        expect(subject).to be_a(Float)
+      end
+    end
+  end
+
+  context 'when bad ldap url' do
+    let(:uri) { 'ldap://blabfoobarurghxxxx.com' }
+    subject(:ldap) { Net::Ping::LDAP.new(uri) }
+    describe '#ping' do
+      subject { ldap.ping }
+      it 'ping basic functionality' do
+        expect { subject }.to_not raise_error
+        expect(subject).to eql(false)
+      end
+    end
+    describe '#ping?' do
+      subject { ldap.ping? }
+      it 'returns a boolean' do
+        expect(subject).to eql(false)
+      end
+    end
+    describe '#pingecho' do
+      subject { ldap.pingecho }
+      it 'returns a boolean' do
+        expect(subject).to eql(false)
+      end
+    end
+    describe '#duration' do
+      subject { ldap.duration }
+      before  { ldap.ping }
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+  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