igp 0.0.3 → 1.0.0

data/spec/base_spec.rb

@@ -2,65 +2,65 @@ 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}
-      base = Igp::Base.new(options)
-      base.ping_handler.should be_a(Net::Ping::External)
-    end
-    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)
-    end
-    it "should be Net::Ping::TCP for :tcp" do
-      options = { :type => :tcp, :host => 'localhost', :port => 22}
+
+  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::TCP)
+      expect(base.ping_handler).to be_a(Net::Ping::External)
     end
-    it "should be Net::Ping::HTTP for :http" do
-      options = { :type => :http, :url => 'http://localhost'}
+    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::HTTP)
+      expect(base.ping_handler).to be_a(Net::Ping::UDP)
     end
-    it "should be Net::Ping::HTTP for :https" do
-      options = { :type => :https, :url => 'https://localhost'}
+    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::HTTP)
+      expect(base.ping_handler).to be_a(Net::Ping::TCP)
     end
-    it "should be Net::Ping::LDAP for :ldap" do
-      options = { :type => :ldap, :url => 'ldap://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::LDAP)
+      expect(base.ping_handler).to be_a(Net::Ping::HTTP)
     end
-    it "should be Net::Ping::LDAP for :ldaps" do
-      options = { :type => :ldaps, :url => 'ldaps://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::LDAP)
+      expect(base.ping_handler).to be_a(Net::Ping::HTTP)
     end
+    # 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
+  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/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

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