igp 0.0.1 → 1.0.0

data/lib/igp/shell.rb

@@ -1,6 +1,7 @@
 require 'uri'
-class Igp::Shell
 
+# class that groks the igp command line options and invokes the ping task
+class Igp::Shell
   # holds the parsed options
   attr_reader :options
   # holds the URI object representing the ping target
@@ -12,12 +13,13 @@ class Igp::Shell
   #
   # +args+ is the remaining command line arguments
   #
-  def initialize(options,args)
+  def initialize(options, args)
     defaults = {
-      :interval => 1
+      interval: 1
     }
-    @options = defaults.merge( (options||{}).each{|k|k} )
+    @options = defaults.merge((options || {}).each { |k, v| { k => v } })
     return unless args.first
+
     resolve_addressing args.first
     normalise_options
   end
@@ -30,7 +32,7 @@ class Igp::Shell
     unless uri.scheme
       @options[:type] = :icmp
       @options[:host] = uri.to_s
-      @options[:url] = "#{@options[:type].to_s}://#{@options[:host]}"
+      @options[:url] = "#{@options[:type]}://#{@options[:host]}"
       return
     end
     @options[:url] = uri.to_s
@@ -50,7 +52,8 @@ class Igp::Shell
   # runs the ping task
   def run
     case options[:type]
-    when :icmp,:http,:https,:tcp,:udp,:ldap,:ldaps
+    # TODO: LDAP was retired from net-ping. to add back in one way or another
+    when :icmp, :http, :https, :tcp, :udp # :ldap, :ldaps
       Igp::Base.new(options).run
     else
       usage
@@ -58,49 +61,50 @@ class Igp::Shell
   end
 
   # defines the valid command line options
-  OPTIONS = %w(help verbose interval=i limit=i)
+  OPTIONS = %w[help verbose interval=i limit=i].freeze
 
   # prints usage/help information
   def usage
     self.class.usage
   end
+
   # prints usage/help information
   def self.usage
-    $stderr.puts <<-EOS
+    $stderr.puts <<~EOS
 
-It goes PING! v#{Igp::VERSION}
-===================================
+      It goes PING! v#{Igp::VERSION}
+      ===================================
 
-Usage:
-  igp [options] uri
-  
-Options:
-  -h | --help    :shows command help
-  -i= | --interval=seconds (default: 1 second)
-  -l= | --limit=number of tests (default: infinite)
+      Usage:
+        igp [options] uri
 
-The uri specifies the protocol, hostname and port.
-The ICMP protocol is assumed if not specified.
-The default well-known port is assumed if not specified.
+      Options:
+        -h | --help    :shows command help
+        -i= | --interval=seconds (default: 1 second)
+        -l= | --limit=number of tests (default: infinite)
 
-Examples:
+      The uri specifies the protocol, hostname and port.
+      The ICMP protocol is assumed if not specified.
+      The default well-known port is assumed if not specified.
 
-  ICMP ping:
-    igp localhost
-    igp icmp://localhost
+      Examples:
 
-  UDP/TCP ping:
-    igp udp://localhost:123
-    igp tcp://localhost:843
+        ICMP ping:
+          igp localhost
+          igp icmp://localhost
 
-  HTTP/S ping:
-    igp http://localhost:8080
-    igp https://localhost:4443
+        UDP/TCP ping:
+          igp udp://localhost:123
+          igp tcp://localhost:843
 
-  LDAP/S ping:
-    igp ldap://localhost
-    igp ldaps://localhost:6636
+        HTTP/S ping:
+          igp http://localhost:8080
+          igp https://localhost:4443
 
     EOS
+    # TODO: LDAP was retired from net-ping. to add back in one way or another
+    # LDAP/S ping:
+    #   igp ldap://localhost
+    #   igp ldaps://localhost:6636
   end
-end
+end

data/lib/igp/version.rb

@@ -1,3 +1,3 @@
 class Igp
-  VERSION = "0.0.1"
+  VERSION = '1.0.0'.freeze
 end

data/spec/base_spec.rb

@@ -2,58 +2,65 @@ require 'spec_helper'
 require 'getoptions'
 
 describe Igp::Base do
-
-  describe "base initialization without options" do
-    before do
-      @base = Igp::Base.new
-    end
-    it "should not set ping_handler" do
-      @base.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
-      @base.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
-      @base.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.class.should eql(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'}
-      base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::LDAP)
+    # TODO: LDAP was retired from net-ping. to add back in one way or another
+    # it 'should be Net::Ping::LDAP for :ldap' do
+    #   options = { type: :ldap, url: 'ldap://localhost' }
+    #   base = Igp::Base.new(options)
+    #   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' }
+    #   base = Igp::Base.new(options)
+    #   expect(base.ping_handler).to be_a(Net::Ping::LDAP)
+    # end
+  end
+
+  describe '#run' do
+    before do
+      @good = Igp::Base.new({ type: :icmp, host: 'localhost', port: nil, limit: 1 })
     end
-    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)
+    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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'getoptions'
+
+describe Igp::Base::Format do
+  describe '#duration' do
+    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
+      result = subject.duration(1.0)
+      expect(result).to match(/^\d+\.\d{6}$/)
+      expect(result.to_f).to eql(1.0)
+    end
+    it 'should handle integer parameter' do
+      result = subject.duration(1)
+      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) }
+      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) }
+      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) }
+      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) }
+      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') }
+      expect(result).to match(/^.+Z,false,,message$/)
+    end
+  end
+end

data/spec/shell_spec.rb

@@ -2,22 +2,21 @@ require 'spec_helper'
 require 'getoptions'
 
 describe Igp::Shell do
-
-  describe "base configuration" do
+  describe 'base configuration' do
     context 'without destination specified' do
       before do
         @options = GetOptions.new(Igp::Shell::OPTIONS, [])
       end
-      it "should initialize without error" do
-        expect { Igp::Shell.new(@options,[]) }.to_not raise_error
+      it 'should initialize without error' do
+        expect { Igp::Shell.new(@options, []) }.to_not raise_error
       end
-      it "should provide help/usage" do
-        Igp::Shell.respond_to?(:usage).should be_true
-        Igp::Shell.new(@options,[]).respond_to?(:usage).should be_true
+      it 'should provide help/usage' do
+        expect(Igp::Shell).to respond_to(:usage)
+        expect(Igp::Shell.new(@options, [])).to respond_to(:usage)
       end
-      it "should print usage when run" do
-        shell = Igp::Shell.new(@options,[])
-        shell.should_receive(:usage)
+      it 'should print usage when run' do
+        shell = Igp::Shell.new(@options, [])
+        expect(shell).to receive(:usage)
         shell.run
       end
     end
@@ -25,137 +24,137 @@ describe Igp::Shell do
       before do
         @options_server_value = 'example.com'
         @options = GetOptions.new(Igp::Shell::OPTIONS, [])
-        @shell = Igp::Shell.new(@options,[@options_server_value])
+        @shell = Igp::Shell.new(@options, [@options_server_value])
       end
-      it "should default to 1 second infinte intervals" do
-        @shell.options[:interval].should eql(1)
-        @shell.options[:limit].should be_nil
+      it 'should default to 1 second infinte intervals' do
+        expect(@shell.options[:interval]).to eql(1)
+        expect(@shell.options[:limit]).to be_nil
       end
-      it "should accept server and default to icmp ping" do
-        @shell.options[:host].should eql(@options_server_value)
-        @shell.options[:type].should eql(:icmp)
+      it 'should accept server and default to icmp ping' do
+        expect(@shell.options[:host]).to eql(@options_server_value)
+        expect(@shell.options[:type]).to eql(:icmp)
       end
     end
   end
-  
-  describe "tcp configuration" do
+
+  describe 'tcp configuration' do
     before(:each) do
       @type = :tcp
       @host = 'localhost'
       @port = 843
-      @options_server_value = "#{@type.to_s}://#{@host}:#{@port}"
+      @options_server_value = "#{@type}://#{@host}:#{@port}"
       @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
     end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
+    it 'should support url accessor' do
+      expect(@shell.options[:url]).to eql(@options_server_value)
     end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
+    it 'should default to tcp ping with url when given server with tcp protocol setting' do
+      expect(@shell.options[:type]).to eql(@type)
     end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
+    it 'should resolve host/port' do
+      expect(@shell.options[:host]).to eql(@host)
+      expect(@shell.options[:port]).to eql(@port)
     end
   end
 
-  describe "udp configuration" do
+  describe 'udp configuration' do
     before(:each) do
       @type = :udp
       @host = 'localhost'
       @port = 22
-      @options_server_value = "#{@type.to_s}://#{@host}:#{@port}"
+      @options_server_value = "#{@type}://#{@host}:#{@port}"
       @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
     end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
+    it 'should support url accessor' do
+      expect(@shell.options[:url]).to eql(@options_server_value)
     end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
+    it 'should default to tcp ping with url when given server with tcp protocol setting' do
+      expect(@shell.options[:type]).to eql(@type)
     end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
+    it 'should resolve host/port' do
+      expect(@shell.options[:host]).to eql(@host)
+      expect(@shell.options[:port]).to eql(@port)
     end
   end
 
-  describe "http configuration" do
+  describe 'http configuration' do
     before(:each) do
       @type = :http
       @host = 'localhost'
       @port = 80
-      @options_server_value = "#{@type.to_s}://#{@host}"
+      @options_server_value = "#{@type}://#{@host}"
       @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
     end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
+    it 'should support url accessor' do
+      expect(@shell.options[:url]).to eql(@options_server_value)
     end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
+    it 'should default to tcp ping with url when given server with tcp protocol setting' do
+      expect(@shell.options[:type]).to eql(@type)
     end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
+    it 'should resolve host/port' do
+      expect(@shell.options[:host]).to eql(@host)
+      expect(@shell.options[:port]).to eql(@port)
     end
   end
 
-  describe "https configuration" do
+  describe 'https configuration' do
     before(:each) do
       @type = :https
       @host = 'localhost'
       @port = 443
-      @options_server_value = "#{@type.to_s}://#{@host}"
+      @options_server_value = "#{@type}://#{@host}"
       @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
     end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
+    it 'should support url accessor' do
+      expect(@shell.options[:url]).to eql(@options_server_value)
     end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
+    it 'should default to tcp ping with url when given server with tcp protocol setting' do
+      expect(@shell.options[:type]).to eql(@type)
     end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
+    it 'should resolve host/port' do
+      expect(@shell.options[:host]).to eql(@host)
+      expect(@shell.options[:port]).to eql(@port)
     end
   end
 
-  describe "ldap configuration" do
-    before(:each) do
-      @type = :ldap
-      @host = 'localhost'
-      @port = 389
-      @options_server_value = "#{@type.to_s}://#{@host}"
-      @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
-    end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
-    end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
-    end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
-    end
-  end
-
-  describe "ldaps configuration" do
-    before(:each) do
-      @type = :ldaps
-      @host = 'localhost'
-      @port = 636
-      @options_server_value = "#{@type.to_s}://#{@host}"
-      @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
-    end
-    it "should support url accessor" do
-      @shell.options[:url].should eql(@options_server_value)
-    end
-    it "should default to tcp ping with url when given server with tcp protocol setting" do
-      @shell.options[:type].should eql(@type)
-    end
-    it "should resolve host/port" do
-      @shell.options[:host].should eql(@host)
-      @shell.options[:port].should eql(@port)
-    end
-  end
+  # TODO: LDAP was retired from net-ping. to add back in one way or another
+  # describe 'ldap configuration' do
+  #   before(:each) do
+  #     @type = :ldap
+  #     @host = 'localhost'
+  #     @port = 389
+  #     @options_server_value = "#{@type}://#{@host}"
+  #     @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
+  #   end
+  #   it 'should support url accessor' do
+  #     expect(@shell.options[:url]).to eql(@options_server_value)
+  #   end
+  #   it 'should default to tcp ping with url when given server with tcp protocol setting' do
+  #     expect(@shell.options[:type]).to eql(@type)
+  #   end
+  #   it 'should resolve host/port' do
+  #     expect(@shell.options[:host]).to eql(@host)
+  #     expect(@shell.options[:port]).to eql(@port)
+  #   end
+  # end
 
-end
+  # describe 'ldaps configuration' do
+  #   before(:each) do
+  #     @type = :ldaps
+  #     @host = 'localhost'
+  #     @port = 636
+  #     @options_server_value = "#{@type}://#{@host}"
+  #     @shell = Igp::Shell.new(GetOptions.new(Igp::Shell::OPTIONS, []), [@options_server_value])
+  #   end
+  #   it 'should support url accessor' do
+  #     expect(@shell.options[:url]).to eql(@options_server_value)
+  #   end
+  #   it 'should default to tcp ping with url when given server with tcp protocol setting' do
+  #     expect(@shell.options[:type]).to eql(@type)
+  #   end
+  #   it 'should resolve host/port' do
+  #     expect(@shell.options[:host]).to eql(@host)
+  #     expect(@shell.options[:port]).to eql(@port)
+  #   end
+  # end
+end

data/spec/spec_helper.rb

@@ -1 +1,14 @@
 require 'igp'
+require 'stringio'
+
+def capture(*streams)
+  streams.map!(&:to_s)
+  begin
+    result = StringIO.new
+    streams.each { |stream| eval "$#{stream} = result # $#{stream} = result" }
+    yield
+  ensure
+    streams.each { |stream| eval("$#{stream} = #{stream.upcase} # $#{stream} = #{stream.upcase}") }
+  end
+  result.string
+end