ronin-support 0.5.1 → 0.5.2

data/spec/network/http/proxy_spec.rb

@@ -8,40 +8,40 @@ describe Network::HTTP::Proxy do
     it "should parse host-names" do
       proxy = subject.parse('127.0.0.1')
 
-      proxy.host.should == '127.0.0.1'
+      expect(proxy.host).to eq('127.0.0.1')
     end
 
     it "should parse 'host:port' URLs" do
       proxy = subject.parse('127.0.0.1:80')
 
-      proxy.host.should == '127.0.0.1'
-      proxy.port.should == 80
+      expect(proxy.host).to eq('127.0.0.1')
+      expect(proxy.port).to eq(80)
     end
 
     it "should parse 'user@host:port' URLs" do
       proxy = subject.parse('joe@127.0.0.1:80')
 
-      proxy.user.should == 'joe'
-      proxy.host.should == '127.0.0.1'
-      proxy.port.should == 80
+      expect(proxy.user).to eq('joe')
+      expect(proxy.host).to eq('127.0.0.1')
+      expect(proxy.port).to eq(80)
     end
 
     it "should prase 'user:password@host:port' URLs" do
       proxy = subject.parse('joe:lol@127.0.0.1:80')
 
-      proxy.user.should == 'joe'
-      proxy.password.should == 'lol'
-      proxy.host.should == '127.0.0.1'
-      proxy.port.should == 80
+      expect(proxy.user).to eq('joe')
+      expect(proxy.password).to eq('lol')
+      expect(proxy.host).to eq('127.0.0.1')
+      expect(proxy.port).to eq(80)
     end
 
     it "should ignore http:// prefixes when parsing proxy URLs" do
       proxy = subject.parse('http://joe:lol@127.0.0.1:80')
 
-      proxy.user.should == 'joe'
-      proxy.password.should == 'lol'
-      proxy.host.should == '127.0.0.1'
-      proxy.port.should == 80
+      expect(proxy.user).to eq('joe')
+      expect(proxy.password).to eq('lol')
+      expect(proxy.host).to eq('127.0.0.1')
+      expect(proxy.port).to eq(80)
     end
   end
 
@@ -54,55 +54,55 @@ describe Network::HTTP::Proxy do
     it "should accept Proxy objects" do
       proxy = subject.new(:host => host, :port => port)
 
-      subject.create(proxy).should == proxy
+      expect(subject.create(proxy)).to eq(proxy)
     end
 
     it "should accept URI::HTTP objects" do
       url = URI::HTTP.build(:host => host, :port => port)
       proxy = subject.create(url)
 
-      proxy.host.should == host
-      proxy.port.should == port
+      expect(proxy.host).to eq(host)
+      expect(proxy.port).to eq(port)
     end
 
     it "should accept Hash objects" do
       hash = {:host => host, :port => port}
       proxy = subject.create(hash)
 
-      proxy.host.should == host
-      proxy.port.should == port
+      expect(proxy.host).to eq(host)
+      expect(proxy.port).to eq(port)
     end
 
     it "should accept String objects" do
       string = "#{host}:#{port}"
       proxy = subject.create(string)
 
-      proxy.host.should == host
-      proxy.port.should == port
+      expect(proxy.host).to eq(host)
+      expect(proxy.port).to eq(port)
     end
 
     it "should accept nil" do
       proxy = subject.create(nil)
 
-      proxy.should_not be_enabled
+      expect(proxy).not_to be_enabled
     end
   end
 
   it "should behave like a Hash" do
     subject[:host] = 'example.com'
-    subject[:host].should == 'example.com'
+    expect(subject[:host]).to eq('example.com')
   end
 
   it "should not have a host by default" do
-    subject.host.should be_nil
+    expect(subject.host).to be_nil
   end
 
   it "should not have a port by default" do
-    subject.port.should be_nil
+    expect(subject.port).to be_nil
   end
 
   it "should be disabled by default" do
-    subject.should_not be_enabled
+    expect(subject).not_to be_enabled
   end
 
   it "should reset the host, port, user and password when disabled" do
@@ -113,10 +113,10 @@ describe Network::HTTP::Proxy do
 
     subject.disable!
 
-    subject[:host].should be_nil
-    subject[:port].should be_nil
-    subject[:user].should be_nil
-    subject[:password].should be_nil
+    expect(subject[:host]).to be_nil
+    expect(subject[:port]).to be_nil
+    expect(subject[:user]).to be_nil
+    expect(subject[:password]).to be_nil
   end
 
   it "should return a URI::HTTP representing the proxy" do
@@ -127,22 +127,22 @@ describe Network::HTTP::Proxy do
 
     url = subject.url
 
-    url.host.should == 'example.com'
-    url.port.should == 9001
-    url.user.should == 'joe'
-    url.password.should == 'lol'
+    expect(url.host).to eq('example.com')
+    expect(url.port).to eq(9001)
+    expect(url.user).to eq('joe')
+    expect(url.password).to eq('lol')
   end
 
   it "should return nil when converting a disabled proxy to a URL" do
-    subject.url.should be_nil
+    expect(subject.url).to be_nil
   end
 
   it "should return the host-name when converted to a String" do
     subject[:host] = 'example.com'
-    subject.to_s.should == 'example.com'
+    expect(subject.to_s).to eq('example.com')
   end
 
   it "should return an empty String when there is no host-name" do
-    subject.to_s.should be_empty
+    expect(subject.to_s).to be_empty
   end
 end

data/spec/network/network_spec.rb

@@ -3,6 +3,6 @@ require 'ronin/network/network'
 
 describe Network do
   it "should determine our public facing IP Address", :network do
-    subject.ip.should_not be_nil
+    expect(subject.ip).not_to be_nil
   end
 end

data/spec/network/proxy_spec.rb

@@ -24,8 +24,8 @@ describe Network::Proxy do
         :server => [server_host, server_port]
       )
 
-      proxy.port.should == port
-      proxy.host.should == '0.0.0.0'
+      expect(proxy.port).to eq(port)
+      expect(proxy.host).to eq('0.0.0.0')
     end
 
     it "should allow setting both the host and port" do
@@ -35,8 +35,8 @@ describe Network::Proxy do
         :server => [server_host, server_port]
       )
 
-      proxy.port.should == port
-      proxy.host.should == host
+      expect(proxy.port).to eq(port)
+      expect(proxy.host).to eq(host)
     end
 
     it "should set the server_host and server_port" do
@@ -46,20 +46,20 @@ describe Network::Proxy do
         :server => [server_host, server_port]
       )
 
-      proxy.server_host.should == server_host
-      proxy.server_port.should == server_port
+      expect(proxy.server_host).to eq(server_host)
+      expect(proxy.server_port).to eq(server_port)
     end
   end
 
   describe "#on_data" do
     it "should call on_client_data" do
-      subject.should_receive(:on_client_data)
+      expect(subject).to receive(:on_client_data)
 
       subject.on_data { |client,server,data| }
     end
 
     it "should call on_server_data" do
-      subject.should_receive(:on_server_data)
+      expect(subject).to receive(:on_server_data)
 
       subject.on_data { |client,server,data| }
     end
@@ -68,33 +68,33 @@ describe Network::Proxy do
   describe "actions" do
     describe "#ignore!" do
       it "should throw the :ignore action" do
-        lambda {
+        expect {
           subject.ignore!
-        }.should throw_symbol(:action, :ignore)
+        }.to throw_symbol(:action, :ignore)
       end
     end
 
     describe "#close!" do
       it "should throw the :close action" do
-        lambda {
+        expect {
           subject.close!
-        }.should throw_symbol(:action, :close)
+        }.to throw_symbol(:action, :close)
       end
     end
 
     describe "#reset!" do
       it "should throw the :reset action" do
-        lambda {
+        expect {
           subject.reset!
-        }.should throw_symbol(:action, :reset)
+        }.to throw_symbol(:action, :reset)
       end
     end
 
     describe "#stop!" do
       it "should throw the :stop action" do
-        lambda {
+        expect {
           subject.stop!
-        }.should throw_symbol(:action, :stop)
+        }.to throw_symbol(:action, :stop)
       end
     end
   end
@@ -103,11 +103,11 @@ describe Network::Proxy do
     subject { proxy.to_s }
 
     it "should include the proxy host and port" do
-      subject.should include("#{host}:#{port}")
+      expect(subject).to include("#{host}:#{port}")
     end
 
     it "should include the server host and port" do
-      subject.should include("#{server_host}:#{server_port}")
+      expect(subject).to include("#{server_host}:#{server_port}")
     end
   end
 
@@ -115,7 +115,7 @@ describe Network::Proxy do
     subject { proxy.inspect }
 
     it "should include the output of #to_s" do
-      subject.should include(proxy.to_s)
+      expect(subject).to include(proxy.to_s)
     end
   end
 end

data/spec/network/smtp/email_spec.rb

@@ -8,27 +8,27 @@ describe Network::SMTP::Email do
     it "should default 'date' to Time.now" do
       email = Network::SMTP::Email.new
 
-      email.date.should_not be_nil
+      expect(email.date).not_to be_nil
     end
 
     it "should accept a String body" do
       body = 'hello'
       email = Network::SMTP::Email.new(:body => body)
 
-      email.body.should == [body]
+      expect(email.body).to eq([body])
     end
 
     it "should accept an Array body" do
       body = ['hello', 'world']
       email = Network::SMTP::Email.new(:body => body)
 
-      email.body.should == body
+      expect(email.body).to eq(body)
     end
 
     it "should default 'body' to an empty Array" do
       email = Network::SMTP::Email.new
 
-      email.body.should be_empty
+      expect(email.body).to be_empty
     end
   end
 
@@ -38,39 +38,39 @@ describe Network::SMTP::Email do
     it "should add the 'from'" do
       subject.from = 'joe@example.com'
 
-      subject.to_s.should include("From: joe@example.com\n\r")
+      expect(subject.to_s).to include("From: joe@example.com\n\r")
     end
 
     context "when formatting 'to'" do
       it "should accept an Array of addresses" do
         subject.to = ['alice@example.com', 'joe@example.com']
 
-        subject.to_s.should include("To: alice@example.com, joe@example.com\n\r")
+        expect(subject.to_s).to include("To: alice@example.com, joe@example.com\n\r")
       end
 
       it "should accept a String" do
         subject.to = 'joe@example.com'
 
-        subject.to_s.should include("To: joe@example.com\n\r")
+        expect(subject.to_s).to include("To: joe@example.com\n\r")
       end
     end
 
     it "should add the 'subject'" do
       subject.subject = 'Hello'
 
-      subject.to_s.should include("Subject: Hello\n\r")
+      expect(subject.to_s).to include("Subject: Hello\n\r")
     end
 
     it "should add the 'date'" do
       subject.date = Date.parse('Sun Apr 24 17:22:55 PDT 2011')
 
-      subject.to_s.should include("Date: #{subject.date}\n\r")
+      expect(subject.to_s).to include("Date: #{subject.date}\n\r")
     end
 
     it "should add the 'message_id'" do
       subject.message_id = '1234'
 
-      subject.to_s.should include("Message-Id: <#{subject.message_id}>\n\r")
+      expect(subject.to_s).to include("Message-Id: <#{subject.message_id}>\n\r")
     end
 
     it "should add additional headers" do
@@ -79,21 +79,21 @@ describe Network::SMTP::Email do
 
       lines = subject.to_s.split("\n\r")
       
-      lines.should include('X-Foo: Bar')
-      lines.should include('X-Baz: Quix')
+      expect(lines).to include('X-Foo: Bar')
+      expect(lines).to include('X-Baz: Quix')
     end
 
     context "when formatting 'body'" do
       it "should append each line with a CRLF" do
         subject.body = ['hello', 'world']
 
-        subject.to_s.should include("hello\n\rworld")
+        expect(subject.to_s).to include("hello\n\rworld")
       end
 
       it "should add a CRLF before the body" do
         subject.body = ['hello', 'world']
 
-        subject.to_s.should include("\n\rhello")
+        expect(subject.to_s).to include("\n\rhello")
       end
     end
   end

data/spec/network/ssl_spec.rb

@@ -6,15 +6,15 @@ describe Network::SSL do
     subject { Network::SSL::VERIFY }
 
     it "should map verify mode names to OpenSSL VERIFY_* constants" do
-      subject[:peer].should == OpenSSL::SSL::VERIFY_PEER
+      expect(subject[:peer]).to eq(OpenSSL::SSL::VERIFY_PEER)
     end
 
     it "should default to VERIFY_NONE if no verify mode name is given" do
-      subject[nil].should == OpenSSL::SSL::VERIFY_NONE
+      expect(subject[nil]).to eq(OpenSSL::SSL::VERIFY_NONE)
     end
 
     it "should raise an exception for unknown verify modes" do
-      lambda { subject[:foo_bar] }.should raise_error
+      expect { subject[:foo_bar] }.to raise_error
     end
   end
 
@@ -30,15 +30,15 @@ describe Network::SSL do
 
     describe "#ssl_connect" do
       it "should connect to an SSL protected port" do
-        lambda {
+        expect {
           subject.ssl_connect(host,port)
-        }.should_not raise_error(OpenSSL::SSL::SSLError)
+        }.not_to raise_error
       end
 
       it "should return an OpenSSL::SSL::SSLSocket" do
         socket = subject.ssl_connect(host,port)
 
-        socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
+        expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
       end
 
       context "when a block is given" do
@@ -49,7 +49,7 @@ describe Network::SSL do
             socket = yielded_socket
           end
 
-          socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
+          expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
         end
       end
     end
@@ -62,8 +62,8 @@ describe Network::SSL do
           socket = yielded_socket
         end
 
-        socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
-        socket.should be_closed
+        expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
+        expect(socket).to be_closed
       end
     end
   end

data/spec/network/tcp/proxy_spec.rb

@@ -29,7 +29,7 @@ describe Network::TCP::Proxy, :network => true do
     end
 
     it "should trigger when a new client connects" do
-      @socket.readline.should == injection
+      expect(@socket.readline).to eq(injection)
     end
 
     after { @socket.close }
@@ -47,7 +47,7 @@ describe Network::TCP::Proxy, :network => true do
     end
 
     it "should trigger after a new client connects" do
-      @socket.readline.should == injection
+      expect(@socket.readline).to eq(injection)
     end
 
     after { @socket.close }
@@ -56,16 +56,18 @@ describe Network::TCP::Proxy, :network => true do
   describe "#on_client_data" do
     before do
       @proxy.on_client_data do |client,server,data|
-        data.gsub!(/HTTP\/1.1/,'HTTP/1.0')
+        if (match = data.match(/HTTP\/(\d\.\d)/))
+          client.write("HTTP #{match[1]} detected!\r\n")
+        end
       end
 
       @socket = TCPSocket.new(host,port)
     end
 
     it "should trigger when the client sends data" do
-      @socket.write("GET / HTTP/1.1\r\n\r\n")
+      @socket.write("GET /placeholder HTTP/1.0\r\n\r\n")
 
-      @socket.readline.should == "HTTP/1.0 302 Found\r\n"
+      expect(@socket.readline).to eq("HTTP 1.0 detected!\r\n")
     end
 
     after { @socket.close }
@@ -83,7 +85,7 @@ describe Network::TCP::Proxy, :network => true do
     it "should trigger when the server sends data" do
       @socket.write("GET / HTTP/1.0\r\n\r\n")
 
-      @socket.read.should include("Connection: keep-alive\r\n")
+      expect(@socket.read).to include("Connection: keep-alive\r\n")
     end
 
     after { @socket.close }
@@ -103,7 +105,7 @@ describe Network::TCP::Proxy, :network => true do
     it "should trigger when the server closes the connection" do
       @socket.write("GET / HTTP/1.0\r\n\r\n")
 
-      @socket.read.end_with?(injection).should be_true
+      expect(@socket.read.end_with?(injection)).to be(true)
     end
 
     after { @socket.close }