ronin-support 0.5.1 → 0.5.2

data/spec/network/udp/udp_spec.rb

@@ -8,25 +8,37 @@ describe Network::UDP do
     let(:host) { 'scanme.nmap.org' }
     let(:port) { 123 }
 
-    let(:server_host) { 'localhost' }
-    let(:server_ip)   { Resolv.getaddress(server_host) }
-
     subject do
       obj = Object.new
       obj.extend described_class
       obj
     end
 
+    shared_examples "UDP Server" do
+      let(:server_host) { local_host }
+      let(:server_port) { 1024 + rand(65535 - 1024) }
+      let(:server)      { UDPSocket.new }
+      let(:server_bind_ip)   { server.addr[3] }
+      let(:server_bind_port) { server.addr[1] }
+
+      before(:each) { server.bind(server_host,server_port) }
+      after(:each)  { server.close }
+    end
+
     describe "#udp_open?" do
-      let(:host) { '4.2.2.1' }
-      let(:port) { 53 }
+      let(:host) { server_bind_ip   }
+      let(:port) { server_bind_port }
+
+      include_context "UDP Server"
 
       it "should return true for open ports" do
-        subject.udp_open?(host,port).should == true
+        expect(subject.udp_open?(host,port)).to be(true)
       end
 
+      let(:closed_port) { port + 1 }
+
       it "should return false for closed ports" do
-        subject.udp_open?('localhost',rand(1024) + 1).should == false
+        expect(subject.udp_open?(host,closed_port)).to be(false)
       end
 
       it "should have a timeout for firewalled ports" do
@@ -36,40 +48,44 @@ describe Network::UDP do
         subject.udp_open?(host,1337,nil,nil,timeout)
         t2 = Time.now
 
-        (t2 - t1).to_i.should <= timeout
+        expect((t2 - t1).to_i).to be <= timeout
       end
     end
 
     describe "#udp_connect" do
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
       it "should open a UDPSocket" do
         socket = subject.udp_connect(host,port)
 
-        socket.should be_kind_of(UDPSocket)
-        socket.should_not be_closed
+        expect(socket).to be_kind_of(UDPSocket)
+        expect(socket).not_to be_closed
 
         socket.close
       end
 
-      it "should bind to a local port" do
-        socket      = subject.udp_connect(host,port,nil,local_port)
-        bound_port = socket.addr[1]
+      context "when given a local port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a local port" do
+          socket      = subject.udp_connect(host,port,nil,local_port)
+          bound_port = socket.addr[1]
 
-        bound_port.should == local_port
+          expect(bound_port).to eq(local_port)
 
-        socket.close
+          socket.close
+        end
       end
 
-      it "should yield the new UDPSocket" do
-        socket = nil
+      context "when given a block" do
+        it "should yield the new UDPSocket" do
+          socket = nil
 
-        subject.udp_connect(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
+          subject.udp_connect(host,port) do |yielded_socket|
+            socket = yielded_socket
+          end
 
-        socket.should_not be_closed
-        socket.close
+          expect(socket).not_to be_closed
+          socket.close
+        end
       end
     end
 
@@ -83,7 +99,7 @@ describe Network::UDP do
           banner   = socket.readline
           response = socket.readline
 
-          response.start_with?('250').should be_true
+          expect(response.start_with?('250')).to be_true
 
           socket.close
         end
@@ -92,7 +108,7 @@ describe Network::UDP do
           socket      = subject.udp_connect_and_send(data,host,port,nil,local_port)
           bound_port = socket.addr[1]
 
-          bound_port.should == local_port
+          expect(bound_port).to eq(local_port)
 
           socket.close
         end
@@ -105,7 +121,7 @@ describe Network::UDP do
             response = socket.readline
           end
 
-          response.start_with?('250').should be_true
+          expect(response.start_with?('250')).to be_true
 
           socket.close
         end
@@ -122,18 +138,20 @@ describe Network::UDP do
           socket = yielded_socket
         end
 
-        socket.should be_kind_of(UDPSocket)
-        socket.should be_closed
+        expect(socket).to be_kind_of(UDPSocket)
+        expect(socket).to be_closed
       end
 
-      it "should bind to a local host and port" do
-        bound_port = nil
+      context "when given a local host and port" do
+        it "should bind to a local host and port" do
+          bound_port = nil
+
+          subject.udp_session(host,port,nil,local_port) do |socket|
+            bound_port = socket.addr[1]
+          end
 
-        subject.udp_session(host,port,nil,local_port) do |socket|
-          bound_port = socket.addr[1]
+          expect(bound_port).to eq(local_port)
         end
-
-        bound_port.should == local_port
       end
     end
 
@@ -147,98 +165,103 @@ describe Network::UDP do
         it "should read the service banner" do
           banner = subject.udp_banner(host,port)
 
-          banner.start_with?('220').should be_true
+          expect(banner.start_with?('220')).to be_true
         end
 
-        it "should bind to a local host and port" do
-          banner = subject.udp_banner(host,port,nil,local_port)
+        context "when given a local host and port" do
+          it "should bind to a local host and port" do
+            banner = subject.udp_banner(host,port,nil,local_port)
 
-          banner.start_with?('220').should be_true
+            expect(banner.start_with?('220')).to be_true
+          end
         end
 
-        it "should yield the banner" do
-          banner = nil
+        context "when given a block" do
+          it "should yield the banner" do
+            banner = nil
 
-          subject.udp_banner(host,port) do |yielded_banner|
-            banner = yielded_banner
-          end
+            subject.udp_banner(host,port) do |yielded_banner|
+              banner = yielded_banner
+            end
 
-          banner.start_with?('220').should be_true
+            expect(banner.start_with?('220')).to be_true
+          end
         end
       end
     end
 
-    describe "#udp_send" do
-      let(:server) do
-        socket = UDPSocket.new
-        socket.bind(server_host,0)
-        socket
-      end
-      let(:server_port) { server.addr[1] }
+    let(:local_host) { 'localhost' }
+    let(:local_ip)   { '127.0.0.1' } # XXX: UPDSocket defaults to using IPv4
 
-      let(:data)       { "hello\n" }
-      let(:local_port) { 1024 + rand(65535 - 1024) }
+    describe "#udp_send" do
+      include_context "UDP Server"
 
-      after(:all) { server.close }
+      let(:data) { "hello\n" }
 
       it "should send data to a service" do
-        subject.udp_send(data,server_host,server_port)
+        subject.udp_send(data,server_bind_ip,server_bind_port)
 
         mesg = server.recvfrom(data.length)
 
-        mesg[0].should == data
+        expect(mesg[0]).to eq(data)
       end
 
-      it "should bind to a local host and port" do
-        subject.udp_send(data,server_host,server_port,nil,local_port)
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
 
-        mesg = server.recvfrom(data.length)
+        it "should bind to a local host and port" do
+          subject.udp_send(data,server_bind_ip,server_bind_port,server_bind_ip,local_port)
+
+          mesg = server.recvfrom(data.length)
 
-        client_address = mesg[1]
-        client_address[1].should == local_port
+          client_address = mesg[1]
+          expect(client_address[1]).to eq(local_port)
+        end
       end
     end
 
     describe "#udp_server" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
       it "should create a new UDPSocket" do
         server = subject.udp_server
 
-        server.should be_kind_of(UDPSocket)
-        server.should_not be_closed
+        expect(server).to be_kind_of(UDPSocket)
+        expect(server).not_to be_closed
 
         server.close
       end
 
-      it "should bind to a specific port and host" do
-        server      = subject.udp_server(server_port,server_host)
-        bound_host = server.addr[3]
-        bound_port = server.addr[1]
+      context "when given a port and host" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
 
-        bound_host.should == server_ip
-        bound_port.should == server_port
+        it "should bind to a specific port and host" do
+          server      = subject.udp_server(local_port,local_host)
+          bound_host = server.addr[3]
+          bound_port = server.addr[1]
 
-        server.close
-      end
+          expect(bound_host).to eq(local_ip)
+          expect(bound_port).to eq(local_port)
 
-      it "should yield the new UDPSocket" do
-        server = nil
-        
-        subject.udp_server do |yielded_server|
-          server = yielded_server
+          server.close
         end
+      end
 
-        server.should be_kind_of(UDPSocket)
-        server.should_not be_closed
+      context "when a block is given" do
+        it "should yield the new UDPSocket" do
+          server = nil
 
-        server.close
+          subject.udp_server do |yielded_server|
+            server = yielded_server
+          end
+
+          expect(server).to be_kind_of(UDPSocket)
+          expect(server).not_to be_closed
+
+          server.close
+        end
       end
     end
 
     describe "#udp_server_session" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
       it "should create a temporary UDPSocket" do
         server = nil
         
@@ -246,21 +269,25 @@ describe Network::UDP do
           server = yielded_server
         end
 
-        server.should be_kind_of(UDPSocket)
-        server.should be_closed
+        expect(server).to be_kind_of(UDPSocket)
+        expect(server).to be_closed
       end
 
-      it "should bind to a specific port and host" do
-        bound_host = nil
-        bound_port = nil
-        
-        subject.udp_server_session(server_port,server_host) do |yielded_server|
-          bound_host = yielded_server.addr[3]
-          bound_port = yielded_server.addr[1]
-        end
+      context "when given a port and a host" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
 
-        bound_host.should == server_ip
-        bound_port.should == server_port
+        it "should bind to a specific port and host" do
+          bound_host = nil
+          bound_port = nil
+
+          subject.udp_server_session(local_port,local_host) do |new_server|
+            bound_host = new_server.addr[3]
+            bound_port = new_server.addr[1]
+          end
+
+          expect(bound_host).to eq(local_ip)
+          expect(bound_port).to eq(local_port)
+        end
       end
     end
 

data/spec/network/unix_spec.rb

@@ -15,30 +15,29 @@ describe Network::UNIX do
     describe "#unix_open?" do
       include_context "UNIX Server"
 
-      let(:old_path) { socket_path('ronin_old_unix_socket') }
-      let(:bad_path) { socket_path('ronin_bad_unix_socket') }
-
-      before(:all) { UNIXServer.new(old_path).close }
-
       it "should return true for listening UNIX sockets" do
-        subject.unix_open?(path).should == true
+        expect(subject.unix_open?(path)).to be(true)
       end
 
       it "should return false for closed UNIX sockets" do
-        subject.unix_open?(old_path).should == false
+        old_path = socket_path('ronin_old_unix_socket')
+        UNIXServer.new(old_path).close
+
+        expect(subject.unix_open?(old_path)).to be(false)
+
+        FileUtils.rm(old_path)
       end
 
       it "should have a timeout for non-existent UNIX sockets" do
-        timeout = 2
+        bad_path = socket_path('ronin_bad_unix_socket')
+        timeout  = 2
 
         t1 = Time.now
         subject.unix_open?(bad_path,timeout)
         t2 = Time.now
 
-        (t2 - t1).to_i.should <= timeout
+        expect((t2 - t1).to_i).to be <= timeout
       end
-
-      after(:all) { FileUtils.rm(old_path) }
     end
 
     describe "#unix_connect" do
@@ -47,8 +46,8 @@ describe Network::UNIX do
       it "should open a UNIXSocket" do
         socket = subject.unix_connect(path)
 
-        socket.should be_kind_of(UNIXSocket)
-        socket.should_not be_closed
+        expect(socket).to be_kind_of(UNIXSocket)
+        expect(socket).not_to be_closed
 
         socket.close
       end
@@ -60,7 +59,7 @@ describe Network::UNIX do
           socket = yielded_socket
         end
 
-        socket.should_not be_closed
+        expect(socket).not_to be_closed
         socket.close
       end
     end
@@ -74,7 +73,7 @@ describe Network::UNIX do
         socket   = subject.unix_connect_and_send(data,path)
         response = socket.readline
 
-        response.should == data
+        expect(response).to eq(data)
 
         socket.close
        end
@@ -86,7 +85,7 @@ describe Network::UNIX do
           response = socket.readline
         end
 
-        response.should == data
+        expect(response).to eq(data)
 
         socket.close
       end
@@ -102,8 +101,8 @@ describe Network::UNIX do
           socket = yielded_socket
         end
 
-        socket.should be_kind_of(UNIXSocket)
-        socket.should be_closed
+        expect(socket).to be_kind_of(UNIXSocket)
+        expect(socket).to be_closed
       end
     end
 
@@ -121,7 +120,7 @@ describe Network::UNIX do
 
         client.close
 
-        sent.should == data
+        expect(sent).to eq(data)
       end
 
       after(:each) do
@@ -137,8 +136,8 @@ describe Network::UNIX do
       it "should create a new UNIXServer" do
         server = subject.unix_server(server_path)
 
-        server.should be_kind_of(UNIXServer)
-        server.should_not be_closed
+        expect(server).to be_kind_of(UNIXServer)
+        expect(server).not_to be_closed
 
         server.close
       end
@@ -150,8 +149,8 @@ describe Network::UNIX do
           server = yielded_server
         end
 
-        server.should be_kind_of(UNIXServer)
-        server.should_not be_closed
+        expect(server).to be_kind_of(UNIXServer)
+        expect(server).not_to be_closed
 
         server.close
       end
@@ -169,8 +168,8 @@ describe Network::UNIX do
           server = yielded_server
         end
 
-        server.should be_kind_of(UNIXServer)
-        server.should be_closed
+        expect(server).to be_kind_of(UNIXServer)
+        expect(server).to be_closed
       end
 
       after(:each) { FileUtils.rm(server_path) }