ronin-support 0.4.1 → 0.5.2

data/spec/extensions/ip_addr_spec.rb

@@ -7,47 +7,47 @@ describe IPAddr do
       it "should extract a single IPv4 address" do
         addr = '127.0.0.1'
 
-        IPAddr.extract(addr,:ipv4).should == [addr]
+        expect(IPAddr.extract(addr,:ipv4)).to eq([addr])
       end
 
       it "should extract multiple IPv4 addresses" do
         addrs = %w[127.0.0.1 192.168.0.1]
         text = "#{addrs[0]} #{addrs[1]}"
 
-        IPAddr.extract(text,:ipv4).should == addrs
+        expect(IPAddr.extract(text,:ipv4)).to eq(addrs)
       end
 
       it "should extract IPv4 addresses from text" do
         addr = '127.0.0.1'
         text = "ip (#{addr})"
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore leading periods" do
         addr = '127.0.0.1'
         text = ".#{addr}"
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore tailing periods" do
         addr = '127.0.0.1'
         text = "#{addr}."
 
-        IPAddr.extract(text,:ipv4).should == [addr]
+        expect(IPAddr.extract(text,:ipv4)).to eq([addr])
       end
 
       it "should ignore less than 3 octet IPv4 addresses" do
         text = '127.0.0. 1'
 
-        IPAddr.extract(text,:ipv4).should be_empty
+        expect(IPAddr.extract(text,:ipv4)).to be_empty
       end
 
       it "should ignore IPv4 addresses with more than 3 diget octets" do
         text = '127.1111.0.1'
 
-        IPAddr.extract(text,:ipv4).should be_empty
+        expect(IPAddr.extract(text,:ipv4)).to be_empty
       end
     end
 
@@ -55,42 +55,42 @@ describe IPAddr do
       it "should extract a single IPv6 address" do
         addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
 
-        IPAddr.extract(addr,:ipv6).should == [addr]
+        expect(IPAddr.extract(addr,:ipv6)).to eq([addr])
       end
 
       it "should extract multiple IPv6 addresses" do
         addrs = %w[::1 fe80:0000:0000:0000:0204:61ff:fe9d:f156]
         text = "#{addrs[0]} #{addrs[1]}"
 
-        IPAddr.extract(text,:ipv6).should == addrs
+        expect(IPAddr.extract(text,:ipv6)).to eq(addrs)
       end
 
       it "should extract collapsed IPv6 addresses" do
         addr = 'fe80::0204:61ff:fe9d:f156'
         text = "ipv6: #{addr}"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract IPv6 addresses from text" do
         addr = 'fe80:0000:0000:0000:0204:61ff:fe9d:f156'
         text = "hello #{addr} world"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract trailing IPv4 suffixes" do
         addr = '::ffff:192.0.2.128'
         text = "#{addr} 1.1.1.1"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
 
       it "should extract short-hand IPv6 addresses" do
         addr = '::f0:0d'
         text = "ipv6: #{addr}"
 
-        IPAddr.extract(text,:ipv6).should == [addr]
+        expect(IPAddr.extract(text,:ipv6)).to eq([addr])
       end
     end
 
@@ -99,60 +99,86 @@ describe IPAddr do
       ipv6 = '::1'
       text = "ipv4: #{ipv4}, ipv6: #{ipv6}"
 
-      IPAddr.extract(text).should == [ipv4, ipv6]
+      expect(IPAddr.extract(text)).to eq([ipv4, ipv6])
     end
 
     it "should ignore non-IP addresses" do
       text = 'one: two.three.'
 
-      IPAddr.extract(text).should be_empty
+      expect(IPAddr.extract(text)).to be_empty
     end
   end
 
-  context "CIDR addresses" do
-    let(:fixed_addr) { IPAddr.new('10.1.1.2') }
-    let(:class_c) { IPAddr.new('10.1.1.2/24') }
+  describe "each" do
+    context "CIDR addresses" do
+      let(:fixed_addr) { IPAddr.new('10.1.1.2') }
+      let(:class_c) { IPAddr.new('10.1.1.2/24') }
 
-    it "should only iterate over one IP address for an address" do
-      addresses = fixed_addr.map { |ip| IPAddr.new(ip) }
+      it "should only iterate over one IP address for an address" do
+        addresses = fixed_addr.map { |ip| IPAddr.new(ip) }
 
-      addresses.length.should == 1
-      fixed_addr.should include(addresses.first)
-    end
+        expect(addresses.length).to eq(1)
+        expect(fixed_addr).to include(addresses.first)
+      end
 
-    it "should iterate over all IP addresses contained within the IP range" do
-      class_c.each do |ip|
-        class_c.should include(IPAddr.new(ip))
+      it "should iterate over all IP addresses contained within the IP range" do
+        class_c.each do |ip|
+          expect(class_c).to include(IPAddr.new(ip))
+        end
       end
-    end
 
-    it "should return an Enumerator when no block is given" do
-      class_c.each.all? { |ip|
-        class_c.include?(IPAddr.new(ip))
-      }.should == true
+      it "should return an Enumerator when no block is given" do
+        expect(class_c.each.all? { |ip|
+          class_c.include?(IPAddr.new(ip))
+        }).to be(true)
+      end
     end
-  end
 
-  context "globbed addresses" do
-    let(:ipv4_range) { '10.1.1-5.1' }
-    let(:ipv6_range) { '::ff::02-0a::c3' }
+    context "globbed addresses" do
+      let(:ipv4_range) { '10.1.1-5.1' }
+      let(:ipv6_range) { '::ff::02-0a::c3' }
+
+      it "should expand '*' ranges" do
+        octets = IPAddr.each("10.1.1.*").map { |ip| ip.split('.',4).last }
 
-    it "should iterate over all IP addresses in an IPv4 range" do
-      IPAddr.each(ipv4_range) do |ip|
-        ip.should =~ /^10\.1\.[1-5]\.1$/
+        expect(octets).to eq(('1'..'254').to_a)
       end
-    end
 
-    it "should iterate over all IP addresses in an IPv6 range" do
-      IPAddr.each(ipv6_range) do |ip|
-        ip.should =~ /^::ff::0[2-9a]::c3$/
+      it "should expend 'i-j' ranges" do
+        octets = IPAddr.each("10.1.1.10-20").map { |ip| ip.split('.',4).last }
+
+        expect(octets).to eq(('10'..'20').to_a)
       end
-    end
 
-    it "should return an Enumerator when no block is given" do
-      ips = IPAddr.each(ipv4_range)
-      
-      ips.all? { |ip| ip =~ /^10\.1\.[1-5]\.1$/ }.should == true
+      it "should expand 'i,j,k' ranges" do
+        octets = IPAddr.each("10.1.1.1,2,3").map { |ip| ip.split('.',4).last }
+
+        expect(octets).to eq(['1', '2', '3'])
+      end
+
+      it "should expand combination 'i,j-k' ranges" do
+        octets = IPAddr.each("10.1.1.1,3-4").map { |ip| ip.split('.',4).last }
+
+        expect(octets).to eq(['1', '3', '4'])
+      end
+
+      it "should iterate over all IP addresses in an IPv4 range" do
+        IPAddr.each(ipv4_range) do |ip|
+          expect(ip).to match(/^10\.1\.[1-5]\.1$/)
+        end
+      end
+
+      it "should iterate over all IP addresses in an IPv6 range" do
+        IPAddr.each(ipv6_range) do |ip|
+          expect(ip).to match(/^::ff::0[2-9a]::c3$/)
+        end
+      end
+
+      it "should return an Enumerator when no block is given" do
+        ips = IPAddr.each(ipv4_range)
+
+        expect(ips.all? { |ip| ip =~ /^10\.1\.[1-5]\.1$/ }).to be(true)
+      end
     end
   end
 
@@ -163,15 +189,15 @@ describe IPAddr do
     let(:nameserver) { '4.2.2.1' }
 
     it "should lookup the host-name for an IP" do
-      ip.lookup.should include('localhost')
+      expect(ip.lookup).to include('localhost')
     end
 
     it "may lookup host-names via other nameservers" do
-      ip.lookup(nameserver).should be_empty
+      expect(ip.lookup(nameserver)).to be_empty
     end
 
     it "should return an empty Array for unknown IP addresses" do
-      bad_ip.lookup.should be_empty
+      expect(bad_ip.lookup).to be_empty
     end
   end
 end

data/spec/extensions/kernel_spec.rb

@@ -3,28 +3,28 @@ require 'ronin/extensions/kernel'
 
 describe Kernel do
   it "should provide Kernel#try" do
-    Kernel.should respond_to('try')
+    expect(Kernel).to respond_to('try')
   end
 
   describe "#try" do
     it "should return the result of the block if nothing is raised" do
-      try { 2 + 2 }.should == 4
+      expect(try { 2 + 2 }).to eq(4)
     end
 
     it "should return nil if an exception is raised" do
-      try { 2 + 'a' }.should be_nil
+      expect(try { 2 + 'a' }).to be_nil
     end
 
     it "should rescue RuntimeError exceptions" do
-      lambda {
+      expect {
         try { raise(RuntimeError,"something happened",caller) }
-      }.should_not raise_error(RuntimeError)
+      }.not_to raise_error
     end
 
     it "should rescue StandardError exceptions" do
-      lambda {
+      expect {
         try { raise(StandardError,"not allowed to do that",caller) }
-      }.should_not raise_error(StandardError)
+      }.not_to raise_error
     end
   end
 end

data/spec/extensions/regexp_spec.rb

@@ -2,17 +2,49 @@ require 'spec_helper'
 require 'ronin/extensions/regexp'
 
 describe Regexp do
+  describe "WORD" do
+    let(:word) { 'dog' }
+
+    subject { Regexp::WORD }
+
+    it "should not match single letters" do
+      expect(subject.match('A')).to be_nil
+    end
+
+    it "should not match numeric letters" do
+      expect(subject.match("123#{word}123")[0]).to eq(word)
+    end
+
+    it "should not include ending periods" do
+      expect(subject.match("#{word}.")[0]).to eq(word)
+    end
+
+    it "should not include leading punctuation" do
+      expect(subject.match("'#{word}")[0]).to eq(word)
+    end
+
+    it "should not include tailing punctuation" do
+      expect(subject.match("#{word}'")[0]).to eq(word)
+    end
+
+    it "should include punctuation in the middle of the word" do
+      name = "O'Brian"
+
+      expect(subject.match(name)[0]).to eq(name)
+    end
+  end
+
   describe "OCTET" do
     subject { Regexp::OCTET }
 
     it "should match 0 - 255" do
-      (0..255).all? { |n|
+      expect((0..255).all? { |n|
         subject.match(n.to_s)[0] == n.to_s
-      }.should be_true
+      }).to be(true)
     end
 
     it "should not match numbers greater than 255" do
-      subject.match('256')[0].should == '25'
+      expect(subject.match('256')[0]).to eq('25')
     end
   end
 
@@ -22,7 +54,7 @@ describe Regexp do
     it "should match six hexadecimal bytes" do
       mac = '12:34:56:78:9a:bc'
 
-      subject.match(mac)[0].should == mac
+      expect(subject.match(mac)[0]).to eq(mac)
     end
   end
 
@@ -32,37 +64,37 @@ describe Regexp do
     it "should match valid addresses" do
       ip = '127.0.0.1'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match the Any address" do
       ip = '0.0.0.0'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match the broadcast address" do
       ip = '255.255.255.255'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match addresses with netmasks" do
       ip = '10.1.1.1/24'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should not match addresses with octets > 255" do
       ip = '10.1.256.1'
 
-      subject.match(ip).should be_nil
+      expect(subject.match(ip)).to be_nil
     end
 
     it "should not match addresses with more than three digits per octet" do
       ip = '10.1111.1.1'
 
-      subject.match(ip).should be_nil
+      expect(subject.match(ip)).to be_nil
     end
   end
 
@@ -72,25 +104,25 @@ describe Regexp do
     it "should match valid IPv6 addresses" do
       ip = '2001:db8:85a3:0:0:8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv6 addresses with netmasks" do
       ip = '2001:db8:1234::/48'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match truncated IPv6 addresses" do
       ip = '2001:db8:85a3::8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv4-mapped IPv6 addresses" do
       ip = '::ffff:192.0.2.128'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
   end
 
@@ -100,13 +132,13 @@ describe Regexp do
     it "should match IPv4 addresses" do
       ip = '10.1.1.1'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
 
     it "should match IPv6 addresses" do
       ip = '2001:db8:85a3:0:0:8a2e:370:7334'
 
-      subject.match(ip)[0].should == ip
+      expect(subject.match(ip)[0]).to eq(ip)
     end
   end
 
@@ -116,15 +148,15 @@ describe Regexp do
     it "should match valid hostnames" do
       hostname = 'www.google.com'
 
-      subject.match(hostname)[0].should == hostname
+      expect(subject.match(hostname)[0]).to eq(hostname)
     end
 
     it "should not match hostnames without a TLD" do
-      subject.match('foo').should be_nil
+      expect(subject.match('foo')).to be_nil
     end
 
     it "should not match hostnames with unknown TLDs" do
-      subject.match('foo.zzz').should be_nil
+      expect(subject.match('foo.zzz')).to be_nil
     end
   end
 
@@ -134,31 +166,31 @@ describe Regexp do
     it "should match valid user-names" do
       username = 'alice1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should match user-names containing '_' characters" do
       username = 'alice_1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should match user-names containing '.' characters" do
       username = 'alice.1234'
 
-      subject.match(username)[0].should == username
+      expect(subject.match(username)[0]).to eq(username)
     end
 
     it "should not match user-names beginning with numbers" do
-      subject.match('1234bob')[0].should == 'bob'
+      expect(subject.match('1234bob')[0]).to eq('bob')
     end
 
     it "should not match user-names containing spaces" do
-      subject.match('alice eve')[0].should == 'alice'
+      expect(subject.match('alice eve')[0]).to eq('alice')
     end
 
     it "should not match user-names containing other symbols" do
-      subject.match('alice^eve')[0].should == 'alice'
+      expect(subject.match('alice^eve')[0]).to eq('alice')
     end
   end
 
@@ -168,7 +200,35 @@ describe Regexp do
     it "should match valid email addresses" do
       email = 'alice@example.com'
 
-      subject.match(email)[0].should == email
+      expect(subject.match(email)[0]).to eq(email)
+    end
+  end
+
+  describe "PHONE_NUMBER" do
+    subject { Regexp::PHONE_NUMBER }
+
+    it "should match 111-2222" do
+      number = '111-2222'
+
+      expect(subject.match(number)[0]).to eq(number)
+    end
+
+    it "should match 111-2222x9" do
+      number = '111-2222x9'
+
+      expect(subject.match(number)[0]).to eq(number)
+    end
+
+    it "should match 800-111-2222" do
+      number = '800-111-2222'
+
+      expect(subject.match(number)[0]).to eq(number)
+    end
+
+    it "should match 1-800-111-2222" do
+      number = '1-800-111-2222'
+
+      expect(subject.match(number)[0]).to eq(number)
     end
   end
 
@@ -178,23 +238,23 @@ describe Regexp do
     it "should match Strings beginning with a '_' character" do
       identifier = '_foo'
 
-      subject.match(identifier)[0].should == identifier
+      expect(subject.match(identifier)[0]).to eq(identifier)
     end
 
     it "should match Strings ending with a '_' character" do
       identifier = 'foo_'
 
-      subject.match(identifier)[0].should == identifier
+      expect(subject.match(identifier)[0]).to eq(identifier)
     end
 
     it "should not match Strings beginning with numberic characters" do
-      subject.match('1234foo')[0].should == 'foo'
+      expect(subject.match('1234foo')[0]).to eq('foo')
     end
 
     it "should not match Strings not containing any alpha characters" do
       identifier = '_1234_'
 
-      subject.match(identifier).should be_nil
+      expect(subject.match(identifier)).to be_nil
     end
   end
 
@@ -204,15 +264,15 @@ describe Regexp do
     it "should match the '.' separator character" do
       ext = '.txt'
 
-      subject.match(ext)[0].should == ext
+      expect(subject.match(ext)[0]).to eq(ext)
     end
 
     it "should not allow '_' characters" do
-      subject.match('.foo_bar')[0].should == '.foo'
+      expect(subject.match('.foo_bar')[0]).to eq('.foo')
     end
 
     it "should not allow '-' characters" do
-      subject.match('.foo-bar')[0].should == '.foo'
+      expect(subject.match('.foo-bar')[0]).to eq('.foo')
     end
   end
 
@@ -222,13 +282,13 @@ describe Regexp do
     it "should match file names" do
       filename = 'foo_bar'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
 
     it "should match '\\' escapped characters" do
       filename = 'foo\\ bar'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
   end
 
@@ -238,7 +298,7 @@ describe Regexp do
     it "should match the filename and extension" do
       filename = 'foo_bar.txt'
 
-      subject.match(filename)[0].should == filename
+      expect(subject.match(filename)[0]).to eq(filename)
     end
   end
 
@@ -248,19 +308,19 @@ describe Regexp do
     it "should match directory names" do
       dir = 'foo_bar'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
 
     it "should match '.'" do
       dir = '.'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
 
     it "should match '..'" do
       dir = '..'
 
-      subject.match(dir)[0].should == dir
+      expect(subject.match(dir)[0]).to eq(dir)
     end
   end
 
@@ -270,7 +330,7 @@ describe Regexp do
     it "should match multiple directories" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -280,19 +340,19 @@ describe Regexp do
     it "should match absolute paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match trailing '/' characters" do
       path = '/foo/bar/baz/'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should not match relative directories" do
       path = '/foo/./bar/../baz'
 
-      subject.match(path)[0].should == '/foo/'
+      expect(subject.match(path)[0]).to eq('/foo/')
     end
   end
 
@@ -302,13 +362,13 @@ describe Regexp do
     it "should match relative paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -318,7 +378,7 @@ describe Regexp do
     it "should match multiple directories" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -328,19 +388,19 @@ describe Regexp do
     it "should match absolute paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match trailing '/' characters" do
       path = 'C:\\foo\\bar\\baz\\'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should not match relative directories" do
       path = 'C:\\foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == 'C:\\foo\\'
+      expect(subject.match(path)[0]).to eq('C:\\foo\\')
     end
   end
 
@@ -350,13 +410,13 @@ describe Regexp do
     it "should match relative paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -366,13 +426,13 @@ describe Regexp do
     it "should match relative UNIX paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match relative Windows paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -382,13 +442,13 @@ describe Regexp do
     it "should match absolute UNIX paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute Windows paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 
@@ -398,25 +458,25 @@ describe Regexp do
     it "should match relative UNIX paths" do
       path = 'foo/./bar/../baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute UNIX paths" do
       path = '/foo/bar/baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match relative Windows paths" do
       path = 'foo\\.\\bar\\..\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
 
     it "should match absolute Windows paths" do
       path = 'C:\\foo\\bar\\baz'
 
-      subject.match(path)[0].should == path
+      expect(subject.match(path)[0]).to eq(path)
     end
   end
 end