ronin-support 0.5.1 → 1.0.0.beta1

data/spec/network/http/http_spec.rb

@@ -1,466 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/http'
-
-describe Network::HTTP do
-  describe "proxy" do
-    it "should be disabled by default" do
-      subject.proxy.should_not be_enabled
-    end
-  end
-
-  describe "expand_url" do
-    let(:url) { URI('http://example.com:443/path?q=1') }
-
-    it "should accept URI objects" do
-      options = subject.expand_url(url)
-
-      options[:host].should == url.host
-    end
-
-    it "should accept Hashes" do
-      hash = {
-        :host => url.host,
-        :port => url.port,
-      }
-      options = subject.expand_url(hash)
-
-      options[:host].should == url.host
-      options[:port].should == url.port
-    end
-
-    it "should accept Strings" do
-      options = subject.expand_url(url.to_s)
-
-      options[:host].should == url.host
-      options[:port].should == url.port
-    end
-
-    it "should default :path to '/'" do
-      options = subject.expand_url(URI('http://example.com'))
-
-      options[:path].should == '/'
-    end
-
-    it "should append the query-string to the :path options" do
-      options = subject.expand_url(url)
-
-      options[:path].should == "#{url.path}?#{url.query}"
-    end
-
-    it "should set :ssl if the URI scheme is 'https'" do
-      options = subject.expand_url(URI('https://example.com'))
-
-      options[:ssl].should == {}
-    end
-  end
-
-  describe "expand_options" do
-    it "should expand the :ssl option into a Hash" do
-      options = {:ssl => true}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:ssl].should == {}
-    end
-
-    it "should added a default port and path" do
-      options = {:host => 'example.com'}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:port].should == 80
-      expanded_options[:path].should == '/'
-    end
-
-    it "should add the default proxy settings" do
-      options = {:host => 'example.com'}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:proxy].should == subject.proxy
-    end
-
-    it "should disable the proxy settings if :proxy is nil" do
-      options = {:host => 'example.com', :proxy => nil}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:proxy][:host].should be_nil
-      expanded_options[:proxy][:port].should be_nil
-    end
-
-    it "should not modify :proxy if it is a HTTP::Proxy object" do
-      proxy = Network::HTTP::Proxy.new(:host => 'proxy.com', :port => 8181)
-      options = {:host => 'example.com', :proxy => proxy}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:proxy].should == proxy
-    end
-
-    it "should parse the :proxy option" do
-      options = {:host => 'example.com', :proxy => 'http://proxy.com:8181'}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:proxy][:host].should == 'proxy.com'
-      expanded_options[:proxy][:port].should == 8181
-    end
-
-    it "should expand the :url option" do
-      options = {:url => 'http://joe:secret@example.com:8080/bla?var'}
-      expanded_options = subject.expand_options(options)
-
-      expanded_options[:url].should be_nil
-      expanded_options[:host].should == 'example.com'
-      expanded_options[:port].should == 8080
-      expanded_options[:user].should == 'joe'
-      expanded_options[:password].should == 'secret'
-      expanded_options[:path].should == '/bla?var'
-    end
-
-  end
-
-  describe "headers" do
-    it "should convert Symbol options to HTTP Headers" do
-      options = {:user_agent => 'bla', :location => 'test'}
-
-      subject.headers(options).should == {
-        'User-Agent' => 'bla',
-        'Location' => 'test'
-      }
-    end
-
-    it "should convert String options to HTTP Headers" do
-      options = {'user_agent' => 'bla', 'x-powered-by' => 'PHP'}
-
-      subject.headers(options).should == {
-        'User-Agent' => 'bla',
-        'X-Powered-By' => 'PHP'
-      }
-    end
-
-    it "should convert all values to Strings" do
-      mtime = Time.now.to_i
-      options = {:modified_by => mtime, :x_accept => :gzip}
-
-      subject.headers(options).should == {
-        'Modified-By' => mtime.to_s,
-        'X-Accept' => 'gzip'
-      }
-    end
-  end
-
-  describe "request" do
-    it "should handle Symbol names" do
-      subject.request(
-        :method => :get, :path => '/'
-      ).class.should == Net::HTTP::Get
-    end
-
-    it "should handle String names" do
-      subject.request(
-        :method => 'GET', :path => '/'
-      ).class.should == Net::HTTP::Get
-    end
-
-    it "should raise an UnknownRequest exception for invalid names" do
-      lambda {
-        subject.request(:method => :bla)
-      }.should raise_error(subject::UnknownRequest)
-    end
-
-    it "should use a default path" do
-      lambda {
-        subject.request(:method => :get)
-      }.should_not raise_error(ArgumentError)
-    end
-
-    it "should accept the :user option for Basic-Auth" do
-      req = subject.request(:method => :get, :user => 'joe')
-
-      req['authorization'].should == "Basic am9lOg=="
-    end
-
-    it "should accept the :user and :password options for Basic-Auth" do
-      req = subject.request(
-        :method => :get,
-        :user => 'joe',
-        :password => 'secret'
-      )
-
-      req['authorization'].should == "Basic am9lOnNlY3JldA=="
-    end
-
-    it "should create HTTP Copy requests" do
-      req = subject.request(:method => :copy)
-
-      req.class.should == Net::HTTP::Copy
-    end
-
-    it "should create HTTP Delete requests" do
-      req = subject.request(:method => :delete)
-
-      req.class.should == Net::HTTP::Delete
-    end
-
-    it "should create HTTP Get requests" do
-      req = subject.request(:method => :get)
-
-      req.class.should == Net::HTTP::Get
-    end
-
-    it "should create HTTP Head requests" do
-      req = subject.request(:method => :head)
-
-      req.class.should == Net::HTTP::Head
-    end
-
-    it "should create HTTP Lock requests" do
-      req = subject.request(:method => :lock)
-
-      req.class.should == Net::HTTP::Lock
-    end
-
-    it "should create HTTP Mkcol requests" do
-      req = subject.request(:method => :mkcol)
-
-      req.class.should == Net::HTTP::Mkcol
-    end
-
-    it "should create HTTP Move requests" do
-      req = subject.request(:method => :move)
-
-      req.class.should == Net::HTTP::Move
-    end
-
-    it "should create HTTP Options requests" do
-      req = subject.request(:method => :options)
-
-      req.class.should == Net::HTTP::Options
-    end
-
-    it "should create HTTP Post requests" do
-      req = subject.request(:method => :post)
-
-      req.class.should == Net::HTTP::Post
-    end
-
-    it "should create HTTP Propfind requests" do
-      req = subject.request(:method => :propfind)
-
-      req.class.should == Net::HTTP::Propfind
-    end
-
-    it "should create HTTP Proppatch requests" do
-      req = subject.request(:method => :proppatch)
-
-      req.class.should == Net::HTTP::Proppatch
-    end
-
-    it "should create HTTP Trace requests" do
-      req = subject.request(:method => :trace)
-
-      req.class.should == Net::HTTP::Trace
-    end
-
-    it "should create HTTP Unlock requests" do
-      req = subject.request(:method => :unlock)
-
-      req.class.should == Net::HTTP::Unlock
-    end
-
-    it "should raise an ArgumentError when :method is not specified" do
-      lambda {
-        subject.request()
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "helper methods", :network do
-    let(:host) { 'www.google.com' }
-    let(:port) { 80 }
-    let(:path) { '/' }
-    let(:uri)  { URI::HTTP.build(:host => host, :port => 80, :path => path) }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#http_connect" do
-      it "should create a Net::HTTP session" do
-        http = subject.http_connect(:host => host, :port => port)
-        
-        http.should be_kind_of(Net::HTTP)
-        http.should be_started
-
-        http.finish
-      end
-
-      it "should yield the new Net::HTTP session" do
-        http = nil
-
-        subject.http_connect(:url => uri) do |session|
-          http = session
-        end
-
-        http.should be_kind_of(Net::HTTP)
-      end
-
-      it "should allow yielding the expanded options" do
-        expanded_options = nil
-
-        subject.http_connect(:url => uri) do |session,options|
-          expanded_options = options
-        end
-
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
-      end
-    end
-
-    describe "#http_session" do
-      it "should start and then finish a Net::HTTP session" do
-        http = nil
-        
-        subject.http_session(:host => host, :port => port) do |session|
-          http = session
-        end
-        
-        http.should be_kind_of(Net::HTTP)
-        http.should_not be_started
-      end
-
-      it "should allow yielding the Net::HTTP session" do
-        http = nil
-
-        subject.http_session(:url => uri) do |session|
-          http = session
-        end
-        
-        http.should be_kind_of(Net::HTTP)
-      end
-
-      it "should allow yielding the expanded options" do
-        expanded_options = nil
-
-        subject.http_session(:url => uri) do |session,options|
-          expanded_options = options
-        end
-
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
-      end
-    end
-
-    describe "#http_request" do
-      it "should send an arbitrary request and return the response" do
-        response = subject.http_request(:url => uri, :method => :options)
-
-        response.should be_kind_of(Net::HTTPMethodNotAllowed)
-      end
-
-      it "should allow yielding the request" do
-        request = nil
-
-        subject.http_request(:url => uri, :method => :options) do |req|
-          request = req
-        end
-
-        request.should be_kind_of(Net::HTTP::Options)
-      end
-
-      it "should allow yielding the expanded options" do
-        expanded_options = nil
-
-        subject.http_request(:url => uri, :method => :options) do |req,options|
-          expanded_options = options
-        end
-        
-        expanded_options[:host].should == host
-        expanded_options[:port].should == port
-        expanded_options[:path].should == path
-      end
-    end
-
-    describe "#http_status" do
-      it "should return an Integer" do
-        subject.http_status(:url => uri).should be_kind_of(Integer)
-      end
-
-      it "should return the status-code of the Response" do
-        subject.http_status(:url => uri).should == 200
-      end
-    end
-
-    describe "#http_ok?" do
-      it "should check if the Response has code 200" do
-        subject.http_ok?(:url => uri).should == true
-      end
-    end
-
-    describe "#http_server" do
-      let(:url)     { "http://www.php.net/" }
-      let(:headers) { subject.http_get_headers(:url => url) }
-
-      it "should return the 'Server' header" do
-        subject.http_server(:url => url).should == headers['Server']
-      end
-    end
-
-    describe "#http_powered_by" do
-      let(:url)     { "http://www.php.net/" }
-      let(:headers) { subject.http_get_headers(:url => url) }
-
-      it "should return the 'X-Powered-By' header" do
-        subject.http_powered_by(:url => url).should == headers['X-Powered-By']
-      end
-    end
-
-    describe "#http_get_headers" do
-      let(:headers) { subject.http_get_headers(:url => uri) }
-
-      it "should return HTTP Headers" do
-        headers.should_not be_empty
-      end
-
-      it "should format the HTTP Headers accordingly" do
-        format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
-        bad_headers = headers.keys.reject { |name| name =~ format }
-
-        bad_headers.should == []
-      end
-    end
-
-    describe "#http_get_body" do
-      it "should return the response body" do
-        body = subject.http_get_body(:url => uri)
-
-        body.should be_kind_of(String)
-        body.should_not be_empty
-      end
-    end
-
-    describe "#http_post_headers" do
-      let(:headers) { subject.http_post_headers(:url => uri) }
-
-      it "should return HTTP Headers" do
-        headers.should_not be_empty
-      end
-
-      it "should format the HTTP Headers accordingly" do
-        format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
-        bad_headers = headers.keys.reject { |name| name =~ format }
-
-        bad_headers.should == []
-      end
-    end
-
-    describe "#http_post_body" do
-      it "should return the response body" do
-        body = subject.http_post_body(:url => uri)
-
-        body.should be_kind_of(String)
-        body.should_not be_empty
-      end
-    end
-  end
-end

data/spec/network/http/proxy_spec.rb

@@ -1,148 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/http/proxy'
-
-describe Network::HTTP::Proxy do
-  describe "parse" do
-    subject { described_class }
-
-    it "should parse host-names" do
-      proxy = subject.parse('127.0.0.1')
-
-      proxy.host.should == '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
-    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
-    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
-    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
-    end
-  end
-
-  describe "create" do
-    subject { described_class }
-
-    let(:host) { '127.0.0.1' }
-    let(:port) { 8080 }
-
-    it "should accept Proxy objects" do
-      proxy = subject.new(:host => host, :port => port)
-
-      subject.create(proxy).should == 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
-    end
-
-    it "should accept Hash objects" do
-      hash = {:host => host, :port => port}
-      proxy = subject.create(hash)
-
-      proxy.host.should == host
-      proxy.port.should == port
-    end
-
-    it "should accept String objects" do
-      string = "#{host}:#{port}"
-      proxy = subject.create(string)
-
-      proxy.host.should == host
-      proxy.port.should == port
-    end
-
-    it "should accept nil" do
-      proxy = subject.create(nil)
-
-      proxy.should_not be_enabled
-    end
-  end
-
-  it "should behave like a Hash" do
-    subject[:host] = 'example.com'
-    subject[:host].should == 'example.com'
-  end
-
-  it "should not have a host by default" do
-    subject.host.should be_nil
-  end
-
-  it "should not have a port by default" do
-    subject.port.should be_nil
-  end
-
-  it "should be disabled by default" do
-    subject.should_not be_enabled
-  end
-
-  it "should reset the host, port, user and password when disabled" do
-    subject[:host] = 'example.com'
-    subject[:port] = 9001
-    subject[:user] = 'joe'
-    subject[:password] = 'lol'
-
-    subject.disable!
-
-    subject[:host].should be_nil
-    subject[:port].should be_nil
-    subject[:user].should be_nil
-    subject[:password].should be_nil
-  end
-
-  it "should return a URI::HTTP representing the proxy" do
-    subject[:host] = 'example.com'
-    subject[:port] = 9001
-    subject[:user] = 'joe'
-    subject[:password] = 'lol'
-
-    url = subject.url
-
-    url.host.should == 'example.com'
-    url.port.should == 9001
-    url.user.should == 'joe'
-    url.password.should == 'lol'
-  end
-
-  it "should return nil when converting a disabled proxy to a URL" do
-    subject.url.should 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'
-  end
-
-  it "should return an empty String when there is no host-name" do
-    subject.to_s.should be_empty
-  end
-end

data/spec/network/network_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/network'
-
-describe Network do
-  it "should determine our public facing IP Address", :network do
-    subject.ip.should_not be_nil
-  end
-end