ruby-nmap 0.7.0 → 0.8.0

data/spec/run_stat_spec.rb

@@ -15,7 +15,7 @@ describe RunStat do
     subject { described_class.new(end_time,elapsed,summary,exit_status) }
 
     it "should convert the RunStat to a String" do
-      subject.to_s.should == "#{end_time} #{elapsed} #{exit_status}"
+      expect(subject.to_s).to eq("#{end_time} #{elapsed} #{exit_status}")
     end
   end
 end

data/spec/scan.xml

@@ -44,6 +44,7 @@
 <taskend task="NSE" time="1374390873"/>
 <host starttime="1374389727" endtime="1374390873"><status state="up" reason="reset"/>
 <address addr="74.207.244.221" addrtype="ipv4"/>
+<address addr="08:00:27:7F:62:DC" addrtype="mac" vendor="Cadmus Computer Systems"/ >
 <hostnames>
 <hostname name="scanme.nmap.org" type="user"/>
 <hostname name="scanme.nmap.org" type="PTR"/>

data/spec/scan_spec.rb

@@ -9,12 +9,12 @@ describe Scan do
     subject { described_class.new(type,protocol) }
 
     it "should accept a type and protocol" do
-      subject.type.should == type
-      subject.protocol.should == protocol
+      expect(subject.type).to eq(type)
+      expect(subject.protocol).to eq(protocol)
     end
 
     it "should default services to []" do
-      subject.services.should == []
+      expect(subject.services).to eq([])
     end
   end
 
@@ -22,7 +22,7 @@ describe Scan do
     subject { described_class.new(type,protocol) }
 
     it "should include the type and protocol" do
-      subject.to_s.should == "#{protocol} #{type}"
+      expect(subject.to_s).to eq("#{protocol} #{type}")
     end
   end
 end

data/spec/scan_task_spec.rb

@@ -19,17 +19,17 @@ describe ScanTask do
 
   describe "#duration" do
     it "should be > 0" do
-      subject.duration.should > 0
+      expect(subject.duration).to be > 0
     end
 
     it "should be the time between the start_time and end_time" do
-      (subject.start_time + subject.duration).should == subject.end_time
+      expect(subject.start_time + subject.duration).to eq(subject.end_time)
     end
   end
 
   describe "#to_s" do
     it "should include the start_time, name and extrainfo" do
-      subject.to_s.should == "#{start_time}: #{name} (#{extrainfo})"
+      expect(subject.to_s).to eq("#{start_time}: #{name} (#{extrainfo})")
     end
   end
 end

data/spec/scanner_spec.rb

@@ -18,7 +18,7 @@ describe Scanner do
     end
 
     it "should return the scanner command" do
-      subject.to_s.should == "#{name} #{args}"
+      expect(subject.to_s).to eq("#{name} #{args}")
     end
   end
 end

data/spec/scripts_examples.rb

@@ -4,7 +4,7 @@ shared_examples_for "#scripts" do
   describe "#scripts" do
     subject { super().scripts }
 
-    it { should be_kind_of(Hash) }
-    it { should_not be_empty     }
+    it { is_expected.to be_kind_of(Hash) }
+    it { is_expected.not_to be_empty     }
   end
 end

data/spec/sequence_examples.rb

@@ -4,7 +4,9 @@ shared_examples_for "Sequence" do
   describe "#values" do
     subject { super().values }
 
-    it { should have(6).items }
-    it { should all_be_between(0,0xFFFFFFFF) }
+    it 'has 6 items' do
+      expect(subject.size).to eq(6)
+    end
+    it { is_expected.to all(be_between(0,0xFFFFFFFF)) }
   end
 end

data/spec/service_spec.rb

@@ -9,67 +9,67 @@ describe Service do
 
   describe "#name" do
     it "should parse the name" do
-      subject.name.should == 'ssh'
+      expect(subject.name).to eq('ssh')
     end
   end
 
   describe "#ssl?" do
     it "should check the tunnel attribute" do
-      pending "need a service that uses SSL"
+      skip "need a service that uses SSL"
     end
   end
 
   describe "#protocol" do
     it "should parse the proto attribute" do
-      pending "need a service with the proto attribute"
+      skip "need a service with the proto attribute"
     end
   end
 
   describe "#product" do
     it "should parse the product name attribute" do
-      subject.product.should == 'OpenSSH'
+      expect(subject.product).to eq('OpenSSH')
     end
   end
 
   describe "#version" do
     it "should parse the version attribute" do
-      subject.version.should == '5.3p1 Debian 3ubuntu7'
+      expect(subject.version).to eq('5.3p1 Debian 3ubuntu7')
     end
   end
 
   describe "#extra_info" do
     it "should parse the extrainfo attribute" do
-      subject.extra_info.should == 'protocol 2.0'
+      expect(subject.extra_info).to eq('protocol 2.0')
     end
   end
 
   describe "#hostname" do
     it "should parse the hostname attribute" do
-      pending "need a service with the hostname attribute"
+      skip "need a service with the hostname attribute"
     end
   end
 
   describe "#os_type" do
     it "should parse the ostype attribute" do
-      subject.os_type.should == 'Linux'
+      expect(subject.os_type).to eq('Linux')
     end
   end
 
   describe "#device_type" do
     it "should parse the devicetype attribute" do
-      pending "need a service with the devicetype attribute"
+      skip "need a service with the devicetype attribute"
     end
   end
 
   describe "#fingerprint_method" do
     it "should parse the method attribute" do
-      subject.fingerprint_method.should == :probed
+      expect(subject.fingerprint_method).to eq(:probed)
     end
   end
 
   describe "#confidence" do
     it "should parse the conf attribute" do
-      subject.confidence.should be_between(0,10)
+      expect(subject.confidence).to be_between(0,10)
     end
   end
 

data/spec/spec_helper.rb

@@ -6,32 +6,6 @@ require 'nmap/version'
 require 'nmap/xml'
 include Nmap
 
-RSpec::Matchers.define :be_between do |min,max|
-  match do |value|
-    (value >= min) && (value <= max)
-  end
-end
-
-RSpec::Matchers.define :all_be_between do |min,max|
-  match do |values|
-    values.all? { |value| (value >= min) && (value <= max) }
-  end
-end
-
-RSpec::Matchers.define :be_one_of do |*values|
-  match do |value|
-    values.include?(value)
-  end
-
-  description { "be one of: #{expected.join(', ')}" }
-end
-
-RSpec::Matchers.define :all_be_kind_of do |base_class|
-  match do |values|
-    values.all? { |value| value.kind_of?(base_class) }
-  end
-end
-
 RSpec.configure do |spec|
   spec.before(:all) do
     @xml = XML.new('spec/scan.xml')

data/spec/status_spec.rb

@@ -9,7 +9,7 @@ describe Status do
     subject { described_class.new(state,reason) }
 
     it "should return the state" do
-      subject.to_s.should == state.to_s
+      expect(subject.to_s).to eq(state.to_s)
     end
   end
 end

data/spec/task_spec.rb

@@ -2,35 +2,35 @@ require 'spec_helper'
 require 'nmap/task'
 
 describe Task do
-  describe "ports" do
+  describe "#ports=" do
     it "should ignore empty port Arrays" do
       subject.ports = []
 
-      subject.arguments.should == []
+      expect(subject.arguments).to eq([])
     end
 
     it "should format a String of ports" do
       subject.ports = '80,21,25'
 
-      subject.arguments.should == %w[-p 80,21,25]
+      expect(subject.arguments).to eq(%w[-p 80,21,25])
     end
 
     it "should format an Array of String ports" do
       subject.ports = %w[80 21 25]
 
-      subject.arguments.should == %w[-p 80,21,25]
+      expect(subject.arguments).to eq(%w[-p 80,21,25])
     end
 
     it "should format an Array of Integer ports" do
       subject.ports = [80, 21, 25]
 
-      subject.arguments.should == %w[-p 80,21,25]
+      expect(subject.arguments).to eq(%w[-p 80,21,25])
     end
 
     it "should format a Range of ports" do
       subject.ports = [80, 21..25]
 
-      subject.arguments.should == %w[-p 80,21-25]
+      expect(subject.arguments).to eq(%w[-p 80,21-25])
     end
   end
 end

data/spec/tcp_sequence_spec.rb

@@ -8,13 +8,13 @@ describe TcpSequence do
 
   describe "#index" do
     it "should parse the index" do
-      subject.index.should be > 0
+      expect(subject.index).to be > 0
     end
   end
 
   describe "#description" do
     it "should parse the difficulty description" do
-      subject.difficulty.should == "Good luck!"
+      expect(subject.difficulty).to eq("Good luck!")
     end
   end
 
@@ -36,7 +36,7 @@ describe TcpSequence do
     end
 
     it "should contain the description and values" do
-      subject.to_s.should =~ regexp
+      expect(subject.to_s).to match(regexp)
     end
   end
 

data/spec/tcp_ts_sequence_spec.rb

@@ -8,7 +8,7 @@ describe TcpTsSequence do
 
   describe "#description" do
     it "should parse the description" do
-      subject.description.should == "1000HZ"
+      expect(subject.description).to eq("1000HZ")
     end
   end
 
@@ -26,7 +26,7 @@ describe TcpTsSequence do
     end
 
     it "should contain the description and values" do
-      subject.to_s.should =~ regexp
+      expect(subject.to_s).to match(regexp)
     end
   end
 

data/spec/traceroute_spec.rb

@@ -7,25 +7,36 @@ describe Traceroute do
   describe "#port" do
     subject { super().port }
 
-    it { should be_kind_of(Integer) }
-    it { should be > 0 }
-    it { should be < 65535 }
+    it { is_expected.to be_kind_of(Integer) }
+    it { is_expected.to be > 0 }
+    it { is_expected.to be < 65535 }
   end
 
   describe "#protocol" do
     subject { super().protocol }
 
-    it { should be_kind_of(Symbol) }
-    it { should be_one_of(:tcp, :udp) }
+    it { is_expected.to be_kind_of(Symbol) }
+    it { is_expected.to eq(:tcp).or eq(:udp) }
   end
 
   describe "#each" do
     subject { super().each.first }
 
-    it { should be_kind_of(Hop) }
+    it { is_expected.to be_kind_of(Hop) }
 
-    its(:addr) { should be_kind_of(String)  }
-    its(:ttl)  { should be_kind_of(String)  }
-    its(:rtt)  { should be_kind_of(String)  }
+    describe '#addr' do
+      subject { super().addr }
+      it { is_expected.to be_kind_of(String)  }
+    end
+
+    describe '#ttl' do
+      subject { super().ttl }
+      it { is_expected.to be_kind_of(String)  }
+    end
+
+    describe '#rtt' do
+      subject { super().rtt }
+      it { is_expected.to be_kind_of(String)  }
+    end
   end
 end

data/spec/uptime_spec.rb

@@ -9,7 +9,7 @@ describe Uptime do
     subject { described_class.new(seconds,last_boot) }
 
     it "should convert the uptipe to a String" do
-      subject.to_s.should == "uptime: #{seconds} (#{last_boot})"
+      expect(subject.to_s).to eq("uptime: #{seconds} (#{last_boot})")
     end
   end
 end

data/spec/xml_spec.rb

@@ -11,7 +11,7 @@ describe XML do
       let(:document) { Nokogiri::XML(File.read(path)) }
 
       it "should use the document" do
-        described_class.new(document).version.should == subject.version
+        expect(described_class.new(document).version).to eq(subject.version)
       end
     end
 
@@ -19,36 +19,46 @@ describe XML do
       let(:io) { File.new(path) }
 
       it "should parse the IO object" do
-        described_class.new(io).version.should == subject.version
+        expect(described_class.new(io).version).to eq(subject.version)
       end
     end
 
     context "when given a String" do
       it "should parse the file at the path" do
-        described_class.new(path).version.should == subject.version
+        expect(described_class.new(path).version).to eq(subject.version)
       end
     end
   end
 
-  describe "load" do
-    it "should parse the given text" do
-      subject.version.should == described_class.load(File.read(path)).version
+  describe "parse" do
+    let(:xml) { File.read(path) }
+
+    subject { described_class.parse(xml) }
+
+    it "should return an XML object" do
+      expect(subject).to be_kind_of(described_class)
+    end
+
+    it "should parse the XML" do
+      expect(subject.version).to_not be_nil
     end
   end
 
   describe "open" do
-    it "should parse the given file" do
-      subject.version.should == described_class.open(path).version
+    subject { described_class.open(path) }
+
+    it "should return an XML object" do
+      expect(subject).to be_kind_of(described_class)
     end
 
-    it "should set the path" do
-      subject.path.should == path
+    it "should parse the XML" do
+      expect(subject.version).to_not be_nil
     end
   end
 
   describe "#version" do
     it "should have a version" do
-      subject.version.should == '1.04'
+      expect(subject.version).to eq('1.04')
     end
   end
 
@@ -58,15 +68,15 @@ describe XML do
     end
 
     it "should parse the scanner name" do
-      subject.scanner.name.should == 'nmap'
+      expect(subject.scanner.name).to eq('nmap')
     end
 
     it "should parse the scanner arguments" do
-      subject.scanner.arguments.should == 'nmap -v -sS -sU -A -O -oX spec/scan.xml scanme.nmap.org'
+      expect(subject.scanner.arguments).to eq('nmap -v -sS -sU -A -O -oX spec/scan.xml scanme.nmap.org')
     end
 
     it "should parse the scanner start time" do
-      subject.scanner.start_time.should be_kind_of(Time)
+      expect(subject.scanner.start_time).to be_kind_of(Time)
     end
   end
 
@@ -74,138 +84,166 @@ describe XML do
     subject { super().scan_info.first }
 
     it "should parse the type" do
-      subject.type.should == :syn
+      expect(subject.type).to eq(:syn)
     end
 
     it "should parse the protocol" do
-      subject.protocol.should == :tcp
+      expect(subject.protocol).to eq(:tcp)
     end
 
     it "should parse the services" do
-      subject.services.should_not be_empty
+      expect(subject.services).not_to be_empty
     end
   end
 
   it "should parse the verbose level" do
-    subject.verbose.should == 1
+    expect(subject.verbose).to eq(1)
   end
 
   it "should parse the debugging level" do
-    subject.debugging.should == 0
+    expect(subject.debugging).to eq(0)
   end
 
   describe "#each_run_stat" do
     subject { super().each_run_stat.first }
 
     it "should yield RunStat objects" do
-      subject.should be_kind_of(RunStat)
+      expect(subject).to be_kind_of(RunStat)
     end
 
     it "should parse the end time" do
-      subject.end_time.should be_kind_of(Time)
+      expect(subject.end_time).to be_kind_of(Time)
     end
 
     it "should parse the time elapsed" do
-      subject.elapsed.should_not be_nil
+      expect(subject.elapsed).not_to be_nil
     end
 
     it "should parse the summary" do
-      subject.summary.should_not be_empty
+      expect(subject.summary).not_to be_empty
     end
 
     it "should parse the exit status" do
-      subject.exit_status.should be_one_of('success', 'failure')
+      expect(subject.exit_status).to eq('success').or eq('failure')
     end
   end
 
   describe "#run_stats" do
     subject { super().run_stats }
 
-    it { should_not be_empty }
-    it { should all_be_kind_of(RunStat) }
+    it { is_expected.not_to be_empty }
+    it { is_expected.to all(be_kind_of(RunStat)) }
   end
 
   describe "#each_task" do
     subject { super().each_task.first }
 
     it "should parse task name" do
-      subject.name.should == 'Ping Scan'
+      expect(subject.name).to eq('Ping Scan')
     end
 
     it "should parse the start time" do
-      subject.start_time.should be_kind_of(Time)
+      expect(subject.start_time).to be_kind_of(Time)
     end
 
     it "should parse the end time" do
-      subject.end_time.should be_kind_of(Time)
-      subject.end_time.should > subject.start_time
+      expect(subject.end_time).to be_kind_of(Time)
+      expect(subject.end_time).to be > subject.start_time
     end
 
     it "should parse the extrainfo" do
-      subject.extrainfo.should_not be_empty
+      expect(subject.extrainfo).not_to be_empty
     end
   end
 
   describe "#tasks" do
     subject { super().tasks }
 
-    it { should_not be_empty }
-    it { should all_be_kind_of(ScanTask) }
+    it { is_expected.not_to be_empty }
+    it { is_expected.to all(be_kind_of(ScanTask)) }
   end
 
   describe "#each_host" do
     subject { super().each_host.first }
 
     it "should yield Host objects" do
-      subject.should be_kind_of(Host)
+      expect(subject).to be_kind_of(Host)
     end
   end
 
   describe "#hosts" do
     subject { super().hosts }
 
-    it { should_not be_empty }
-    it { subject.should all_be_kind_of(Host) }
+    it { is_expected.not_to be_empty }
+    it { expect(subject).to all(be_kind_of(Host)) }
+  end
+
+  describe "#host" do
+    subject { super().host }
+
+    it { expect(subject).to be_kind_of(Host) }
+  end
+
+  describe "#down_host" do
+    pending "need down hosts in scan.xml" do
+      subject { super().down_host }
+
+      it { is_expected.to be_kind_of(Host) }
+
+      it "should contain only up hosts" do
+        expect(subject.status.state).to be(:down)
+      end
+    end
   end
 
   describe "#each_up_host" do
     subject { super().each_up_host.first }
 
     it "should yield Host objects" do
-      subject.should be_kind_of(Host)
+      expect(subject).to be_kind_of(Host)
     end
 
     it "should be up" do
-      subject.status.state.should be == :up
+      expect(subject.status.state).to eq(:up)
     end
   end
 
   describe "#up_hosts" do
     subject { super().up_hosts }
 
-    it { should_not be_empty }
-    it { should all_be_kind_of(Host) }
+    it { is_expected.not_to be_empty }
+    it { is_expected.to all(be_kind_of(Host)) }
+
+    it "should contain only up hosts" do
+      expect(subject.all? { |host| host.status.state == :up }).to be_truthy
+    end
+  end
+
+  describe "#up_host" do
+    subject { super().up_host }
+
+    it { is_expected.to be_kind_of(Host) }
 
     it "should contain only up hosts" do
-      subject.all? { |host| host.status.state == :up }.should be_true
+      expect(subject.status.state).to be(:up)
     end
   end
 
   describe "#each" do
     it "should iterate over each up host" do
-      subject.each.all? { |host| host.status.state == :up }.should == true
+      expect(subject.each.all? { |host| host.status.state == :up }).to eq(true)
     end
   end
 
   describe "#to_s" do
     it "should convert to a String" do
-      subject.to_s.should == path
+      expect(subject.to_s).to eq(path)
     end
   end
 
   describe "#inspect" do
     it "should include the class and path" do
-      subject.inspect.should == "#<#{described_class}: #{path}>"
+      expect(subject.inspect).to eq("#<#{described_class}: #{path}>")
     end
   end
 end