ruby-nmap 0.7.0 → 0.8.0

data/spec/cpe_examples.rb

@@ -3,9 +3,9 @@ require 'rspec'
 shared_examples_for "CPE" do
   subject { super().cpe }
 
-  it { should_not be_empty }
+  it { is_expected.not_to be_empty }
 
   it "should contain CPE URLs" do
-    subject.should all_be_kind_of(CPE::URL)
+    expect(subject).to all(be_kind_of(CPE::URL))
   end
 end

data/spec/hop_spec.rb

@@ -8,7 +8,7 @@ describe Hop do
     end
 
     it "should return the addr" do
-      subject.to_s.should == subject.addr
+      expect(subject.to_s).to eq(subject.addr)
     end
   end
 end

data/spec/host_spec.rb

@@ -7,63 +7,65 @@ require 'nmap/host'
 describe Host do
   subject { @xml.hosts.first }
 
-  it "should parse the start_time" do
-    subject.start_time.should > Time.at(0)
+  describe "#start_time" do
+    it "should parse the start_time" do
+      expect(subject.start_time).to be > Time.at(0)
+    end
   end
 
-  it "should parse the end_time" do
-    subject.end_time.should > Time.at(0)
-    subject.end_time.should > subject.start_time
+  describe "#end_time" do
+    it "should parse the end_time" do
+      expect(subject.end_time).to be > Time.at(0)
+      expect(subject.end_time).to be > subject.start_time
+    end
   end
 
   describe "#uptime" do
     subject { super().uptime }
 
     it "should return an Uptime object" do
-      subject.should be_kind_of(Uptime)
+      expect(subject).to be_kind_of(Uptime)
     end
 
     it "should parse the seconds attribute" do
-      subject.seconds.should be > 0
+      expect(subject.seconds).to be > 0
     end
 
     it "should parse the lastboot attribute" do
-      subject.last_boot.should be_kind_of(Time)
+      expect(subject.last_boot).to be_kind_of(Time)
     end
   end
 
   describe "#tcp_sequence" do
     subject { super().tcp_sequence }
 
-    it { should be_kind_of(TcpSequence) }
+    it { is_expected.to be_kind_of(TcpSequence) }
   end
 
   describe "#ip_ip_sequence" do
     subject { super().ip_id_sequence }
 
-    it { should be_kind_of(IpIdSequence) }
+    it { is_expected.to be_kind_of(IpIdSequence) }
   end
 
   describe "#tcp_ts_sequence" do
     subject { super().tcp_ts_sequence }
 
-    it { should be_kind_of(TcpTsSequence) }
+    it { is_expected.to be_kind_of(TcpTsSequence) }
   end
 
   describe "#status" do
     subject { super().status }
 
     it "should parse the state" do
-      subject.state.should be_one_of(:up, :down)
+      expect(subject.state).to eq(:up).or eq(:down)
     end
 
     it "should parse the reason" do
-      subject.reason.should be_one_of(
-        'syn-ack',
-        'timestamp-reply',
-        'echo-reply',
-        'reset'
-      )
+      expect(subject.reason).to eq('syn-ack').or \
+                                eq('timestamp-reply').or \
+                                eq('echo-reply').or \
+                                eq('reset')
     end
   end
 
@@ -71,120 +73,143 @@ describe Host do
     subject { super().addresses.first }
 
     it "should parse the type" do
-      subject.type.should == :ipv4
+      expect(subject.type).to eq(:ipv4)
     end
 
     it "should parser the addr" do
-      subject.addr.should == '74.207.244.221'
+      expect(subject.addr).to eq('74.207.244.221')
     end
+
   end
 
   describe "#mac" do
     it "should parse the first MAC address" do
-      pending "need a host with address[@addrtype='mac']"
+      skip "need a host with address[@addrtype='mac']"
     end
   end
 
   describe "#ipv6" do
     it "should parse the first IPv6 address" do
-      pending "need a host with address[@addrtype='ipv6']"
+      skip "need a host with address[@addrtype='ipv6']"
     end
   end
 
   describe "#ipv4" do
     it "should parse the IPv4 address" do
-      subject.ipv4.should == '74.207.244.221'
+      expect(subject.ipv4).to eq('74.207.244.221')
     end
   end
 
   describe "#ip" do
     it "should have an IP" do
-      subject.ip.should == '74.207.244.221'
+      expect(subject.ip).to eq('74.207.244.221')
     end
   end
 
   describe "#address" do
     it "should have an address" do
-      subject.address.should == '74.207.244.221'
+      expect(subject.address).to eq('74.207.244.221')
     end
   end
 
   describe "#hostnames" do
     subject { super().hostnames }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should parse the type" do
-      subject.all? { |hostname| hostname.type }.should be_true
+      expect(subject.all? { |hostname| hostname.type }).to be_truthy
     end
 
     it "should parse the name" do
-      subject.all? { |hostname| hostname.name }.should be_true
+      expect(subject.all? { |hostname| hostname.name }).to be_truthy
     end
 
     it "should include a user hostname" do
-      subject.any? { |hostname| hostname.type == 'user' }.should be_true
+      expect(subject.any? { |hostname| hostname.type == 'user' }).to be_truthy
     end
 
     it "should include a PTR hostname" do
-      subject.any? { |hostname| hostname.type == 'PTR' }.should be_true
+      expect(subject.any? { |hostname| hostname.type == 'PTR' }).to be_truthy
+    end
+  end
+
+  describe "#hostname" do
+    it "should return the first hostname" do
+      expect(subject.hostname).to be == subject.hostnames.first
     end
   end
 
   describe "#os" do
     subject { super().os }
 
-    it { should_not be_nil }
-    it { should be_kind_of(OS) }
+    it { is_expected.not_to be_nil }
+    it { is_expected.to be_kind_of(OS) }
   end
 
   describe "#ports" do
     subject { super().ports }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
   end
 
   describe "#open_ports" do
     subject { super().open_ports }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should list the open ports" do
-      subject.all? { |port| port.state == :open }.should be_true
+      expect(subject.all? { |port| port.state == :open }).to be_truthy
     end
   end
 
   describe "#tcp_ports" do
     subject { super().tcp_ports }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should contain TCP ports" do
-      subject.all? { |port| port.protocol == :tcp }.should be_true
+      expect(subject.all? { |port| port.protocol == :tcp }).to be_truthy
     end
   end
 
   describe "#udp_ports" do
     subject { super().udp_ports }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should contain UDP ports" do
-      subject.all? { |port| port.protocol == :udp }.should be_true
+      expect(subject.all? { |port| port.protocol == :udp }).to be_truthy
     end
   end
 
-  it "should convert to a String" do
-    subject.to_s.should == '74.207.244.221'
+  describe "#to_s" do
+    it "should return the first hostname" do
+      expect(subject.to_s).to eq('scanme.nmap.org')
+    end
+
+    context "when #hostname returns nil" do
+      before { expect(subject).to receive(:hostname).and_return(nil) }
+
+      it "should return the first address" do
+        expect(subject.to_s).to eq('74.207.244.221')
+      end
+    end
   end
 
   describe "#inspect" do
-    it "should include the address" do
-      subject.inspect.should include(subject.address)
+    it "should include the String representation of the host" do
+      expect(subject.inspect).to include(subject.to_s)
     end
   end
 
-  pending "scan.xml does not currently include any hostscripts" do
+  skip "scan.xml does not currently include any hostscripts" do
     include_examples "#scripts"
   end
+
+  describe "#vendor" do
+    it "should parse the vendor name" do
+      expect(subject.vendor).to eq('Cadmus Computer Systems')
+    end 
+  end
 end

data/spec/hostname_spec.rb

@@ -2,14 +2,31 @@ require 'spec_helper'
 require 'nmap/hostname'
 
 describe Hostname do
+  let(:name) { 'scanme.nmap.org' }
+
+  describe "#user?" do
+    subject { described_class.new('user', name) }
+
+    it "should check if type is 'user'" do
+      expect(subject.user?).to eq(true)
+    end
+  end
+
+  describe "#user?" do
+    subject { described_class.new('PTR', name) }
+
+    it "should check if type is 'PTR'" do
+      expect(subject.ptr?).to eq(true)
+    end
+  end
+
   describe "#to_s" do
-    let(:type) { :user }
-    let(:name) { 'scanme.nmap.org' }
+    let(:type) { 'user' }
 
     subject { described_class.new(type, name) }
 
     it "should return the hostname" do
-      subject.to_s.should == name
+      expect(subject.to_s).to eq(name)
     end
   end
 end

data/spec/ip_id_sequence_spec.rb

@@ -8,7 +8,7 @@ describe IpIdSequence do
 
   describe "#description" do
     it "should parse the description" do
-      subject.description.should == "All zeros"
+      expect(subject.description).to eq("All zeros")
     end
   end
 
@@ -26,7 +26,7 @@ describe IpIdSequence 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/nmap_spec.rb

@@ -4,6 +4,6 @@ require 'nmap/version'
 
 describe Nmap do
   it "should have a VERSION constant" do
-    subject.const_defined?('VERSION').should be_true
+    expect(subject.const_defined?('VERSION')).to be_truthy
   end
 end

data/spec/os_class_spec.rb

@@ -7,24 +7,34 @@ require 'cgi'
 describe OS do
   subject { @xml.hosts.first.os.classes.first }
 
-  it "should parse the type" do
-    subject.type.should == :"general purpose"
+  describe "#type" do
+    it "should parse the type" do
+      expect(subject.type).to eq(:"general purpose")
+    end
   end
 
-  it "should parse the vendor" do
-    subject.vendor.should == 'Linux'
+  describe "#vendor" do
+    it "should parse the vendor" do
+      expect(subject.vendor).to eq('Linux')
+    end
   end
 
-  it "should parse the family" do
-    subject.family.should == :Linux
+  describe "#family" do
+    it "should parse the family" do
+      expect(subject.family).to eq(:Linux)
+    end
   end
 
-  it "should parse the gen" do
-    subject.gen.should == :'2.6.X'
+  describe "#gen" do
+    it "should parse the gen" do
+      expect(subject.gen).to eq(:'2.6.X')
+    end
   end
 
-  it "should parse the accuracy" do
-    subject.accuracy.should be_between(0,100)
+  describe "#accuracy" do
+    it "should parse the accuracy" do
+      expect(subject.accuracy).to be_between(0,100)
+    end
   end
 
   it_should_behave_like "CPE"

data/spec/os_match_spec.rb

@@ -9,7 +9,7 @@ describe OSMatch do
     subject { described_class.new(name,accuracy) }
 
     it "should include the name and accuracy" do
-      subject.to_s.should == "#{name} (#{accuracy}%)"
+      expect(subject.to_s).to eq("#{name} (#{accuracy}%)")
     end
   end
 end

data/spec/os_spec.rb

@@ -9,10 +9,10 @@ describe OS do
   describe "#classes" do
     subject { super().classes }
 
-    it { should_not be_empty }
+    it { is_expected.not_to be_empty }
 
     it "should return OSClass objects" do
-      subject.should all_be_kind_of(OSClass)
+      expect(subject).to all(be_kind_of(OSClass))
     end
   end
 
@@ -20,24 +20,25 @@ describe OS do
     subject { super().matches.first }
 
     it "should parse the name" do
-      subject.name.should == 'Linux 2.6.39'
+      expect(subject.name).to eq('Linux 2.6.39')
     end
 
     it "should parse the accuracy" do
-      subject.accuracy.should be_between(0,100)
+      expect(subject.accuracy).to be_between(0,100)
     end
   end
 
   describe "#ports_used" do
     subject { super().ports_used }
 
-    it { subject.should_not be_empty }
-    it { subject.should all_be_between(0,65535) }
+    it { expect(subject).not_to be_empty }
+    it { expect(subject).to all(be_between(0,65535)) }
   end
 
-  it "should parse the OS fingerprints" do
-    pending "scan.xml does not currently have an osfingerprint" do
-      subject.fingerprint.should == CGI.unescapeHTML("SCAN(V=4.68%D=8/16%OT=443%CT=21%CU=%PV=Y%DS=1%G=N%M=001D7E%TM=48A77607%P=i686-pc-linux-gnu)
SEQ(SP=19%GCD=FA00%ISR=9E%TI=I%TS=1)
OPS(O1=M5B4NW0NNT11%O2=M5B4NW0NNT11%O3=M5B4NW0NNT11%O4=M5B4NW0NNT11%O5=M5B4NW0NNT11%O6=M5B4NNT11)
WIN(W1=2000%W2=2000%W3=2000%W4=2000%W5=2000%W6=2000)
ECN(R=Y%DF=N%TG=40%W=2000%O=M5B4NW0%CC=N%Q=)
T1(R=Y%DF=N%TG=40%S=O%A=S+%F=AS%RD=0%Q=)
T2(R=N)
T3(R=N)
T4(R=N)
T5(R=Y%DF=N%TG=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)
T6(R=N)
T7(R=N)
U1(R=N)
IE(R=N)
")
+  describe "#fingerprint" do
+    it "should parse the OS fingerprints" do
+      pending "scan.xml does not currently have an osfingerprint"
+      expect(subject.fingerprint).to eq(CGI.unescapeHTML("SCAN(V=4.68%D=8/16%OT=443%CT=21%CU=%PV=Y%DS=1%G=N%M=001D7E%TM=48A77607%P=i686-pc-linux-gnu)
SEQ(SP=19%GCD=FA00%ISR=9E%TI=I%TS=1)
OPS(O1=M5B4NW0NNT11%O2=M5B4NW0NNT11%O3=M5B4NW0NNT11%O4=M5B4NW0NNT11%O5=M5B4NW0NNT11%O6=M5B4NNT11)
WIN(W1=2000%W2=2000%W3=2000%W4=2000%W5=2000%W6=2000)
ECN(R=Y%DF=N%TG=40%W=2000%O=M5B4NW0%CC=N%Q=)
T1(R=Y%DF=N%TG=40%S=O%A=S+%F=AS%RD=0%Q=)
T2(R=N)
T3(R=N)
T4(R=N)
T5(R=Y%DF=N%TG=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)
T6(R=N)
T7(R=N)
U1(R=N)
IE(R=N)
"))
     end
   end
 end

data/spec/port_spec.rb

@@ -4,27 +4,35 @@ require 'nmap/port'
 describe Port do
   subject { @xml.hosts.first.ports.first }
 
-  it "should parse the protocol" do
-    subject.protocol.should == :tcp
+  describe "#protocol" do
+    it "should parse the protocol" do
+      expect(subject.protocol).to eq(:tcp)
+    end
   end
 
-  it "should parse the port number" do
-    subject.number.should == 22
+  describe "#number" do
+    it "should parse the port number" do
+      expect(subject.number).to eq(22)
+    end
   end
 
-  it "should parse the state" do
-    subject.state.should == :open
+  describe "#state" do
+    it "should parse the state" do
+      expect(subject.state).to eq(:open)
+    end
   end
 
-  it "should parse the reason" do
-    subject.reason.should == 'syn-ack'
+  describe "#reason" do
+    it "should parse the reason" do
+      expect(subject.reason).to eq('syn-ack')
+    end
   end
 
   describe "#service" do
     subject { super().service }
 
     it "should return a Service object" do
-      subject.should be_kind_of(Service)
+      expect(subject).to be_kind_of(Service)
     end
   end
 
@@ -32,7 +40,7 @@ describe Port do
 
   describe "#inspect" do
     it "should include the number" do
-      subject.inspect.should include(subject.number.to_s)
+      expect(subject.inspect).to include(subject.number.to_s)
     end
   end
 end