ronin-support 0.4.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

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

data/spec/network/proxy_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'ronin/network/proxy'
+
+describe Network::Proxy do
+  let(:port)  { 1337              }
+  let(:host)  { '127.0.0.1'       }
+  let(:server_host) { 'www.example.com' }
+  let(:server_port) { 80                }
+
+  let(:proxy) do
+    described_class.new(
+      :port   => port,
+      :host   => host,
+      :server => [server_host, server_port]
+    )
+  end
+
+  subject { proxy }
+
+  describe "#initialize" do
+    it "should default host to '0.0.0.0'" do
+      proxy = described_class.new(
+        :port   => port,
+        :server => [server_host, server_port]
+      )
+
+      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
+      proxy = described_class.new(
+        :port   => port,
+        :host   => host,
+        :server => [server_host, server_port]
+      )
+
+      expect(proxy.port).to eq(port)
+      expect(proxy.host).to eq(host)
+    end
+
+    it "should set the server_host and server_port" do
+      proxy = described_class.new(
+        :port   => port,
+        :host   => host,
+        :server => [server_host, 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
+      expect(subject).to receive(:on_client_data)
+
+      subject.on_data { |client,server,data| }
+    end
+
+    it "should call on_server_data" do
+      expect(subject).to receive(:on_server_data)
+
+      subject.on_data { |client,server,data| }
+    end
+  end
+
+  describe "actions" do
+    describe "#ignore!" do
+      it "should throw the :ignore action" do
+        expect {
+          subject.ignore!
+        }.to throw_symbol(:action, :ignore)
+      end
+    end
+
+    describe "#close!" do
+      it "should throw the :close action" do
+        expect {
+          subject.close!
+        }.to throw_symbol(:action, :close)
+      end
+    end
+
+    describe "#reset!" do
+      it "should throw the :reset action" do
+        expect {
+          subject.reset!
+        }.to throw_symbol(:action, :reset)
+      end
+    end
+
+    describe "#stop!" do
+      it "should throw the :stop action" do
+        expect {
+          subject.stop!
+        }.to throw_symbol(:action, :stop)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    subject { proxy.to_s }
+
+    it "should include the proxy host and port" do
+      expect(subject).to include("#{host}:#{port}")
+    end
+
+    it "should include the server host and port" do
+      expect(subject).to include("#{server_host}:#{server_port}")
+    end
+  end
+
+  describe "#inspect" do
+    subject { proxy.inspect }
+
+    it "should include the output of #to_s" do
+      expect(subject).to include(proxy.to_s)
+    end
+  end
+end

data/spec/network/shared/unix_server.rb

@@ -0,0 +1,31 @@
+require 'rspec'
+
+require 'tmpdir'
+require 'fileutils'
+require 'socket'
+
+shared_context "UNIX Server" do
+  def socket_path(name); File.join(Dir.tmpdir,name); end
+
+  let(:path) { socket_path('ronin_unix_server') }
+
+  before(:each) do
+    @server = UNIXServer.new(path)
+    @server_thread = Thread.new do
+      socket = @server.accept
+
+      begin
+        socket.puts socket.readline
+      ensure
+        socket.close
+      end
+    end
+  end
+
+  after(:each) do
+    @server_thread.kill
+    @server.close
+
+    FileUtils.rm(path)
+  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,65 @@ 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
+
+  describe "helpers", :network do
+    let(:host) { 'github.com' }
+    let(:port) { 443 }
+
+    subject do
+      obj = Object.new
+      obj.extend described_class
+      obj
+    end
+
+    describe "#ssl_connect" do
+      it "should connect to an SSL protected port" do
+        expect {
+          subject.ssl_connect(host,port)
+        }.not_to raise_error
+      end
+
+      it "should return an OpenSSL::SSL::SSLSocket" do
+        socket = subject.ssl_connect(host,port)
+
+        expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
+      end
+
+      context "when a block is given" do
+        it "should yield the OpenSSL::SSL::SSLSocket" do
+          socket = nil
+
+          subject.ssl_connect(host,port) do |yielded_socket|
+            socket = yielded_socket
+          end
+
+          expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
+        end
+      end
+    end
+
+    describe "#ssl_session" do
+      it "should open then close a OpenSSL::SSL::SSLSocket" do
+        socket = nil
+
+        subject.ssl_session(host,port) do |yielded_socket|
+          socket = yielded_socket
+        end
+
+        expect(socket).to be_kind_of(OpenSSL::SSL::SSLSocket)
+        expect(socket).to be_closed
+      end
     end
   end
 end