ronin-support 0.5.2 → 1.0.0.beta2

data/spec/network/http/http_spec.rb

@@ -1,559 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/http'
-
-describe Network::HTTP do
-  describe "proxy" do
-    it "should be disabled by default" do
-      expect(subject.proxy).not_to 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)
-
-      expect(options[:host]).to eq(url.host)
-    end
-
-    it "should accept Hashes" do
-      hash = {
-        :host => url.host,
-        :port => url.port,
-      }
-      options = subject.expand_url(hash)
-
-      expect(options[:host]).to eq(url.host)
-      expect(options[:port]).to eq(url.port)
-    end
-
-    it "should accept Strings" do
-      options = subject.expand_url(url.to_s)
-
-      expect(options[:host]).to eq(url.host)
-      expect(options[:port]).to eq(url.port)
-    end
-
-    describe ":path" do
-      it "should filter out empty URL paths" do
-        options = subject.expand_url(URI('http://example.com'))
-
-        expect(options[:path]).to be_nil
-      end
-
-      context "when the path is empty" do
-        it "should not be set" do
-          options = subject.expand_url(URI('http://example.com'))
-
-          expect(options).not_to have_key(:path)
-        end
-      end
-    end
-
-    describe ":query" do
-      it "should set :query to the query string" do
-        options = subject.expand_url(url)
-
-        expect(options[:query]).to eq(url.query)
-      end
-
-      context "when query is nil" do
-        it "should not be set" do
-          options = subject.expand_url(URI('http://example.com/path'))
-
-          expect(options).not_to have_key(:query)
-        end
-      end
-
-      context "when query is empty" do
-        it "should be set" do
-          options = subject.expand_url(URI('http://example.com/path?'))
-
-          expect(options[:query]).to be_empty
-        end
-      end
-    end
-
-    it "should set :ssl if the URI scheme is 'https'" do
-      options = subject.expand_url(URI('https://example.com'))
-
-      expect(options[:ssl]).to eq({})
-    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)
-
-      expect(expanded_options[:ssl]).to eq({})
-    end
-
-    it "should added a default port and path" do
-      options = {:host => 'example.com'}
-      expanded_options = subject.expand_options(options)
-
-      expect(expanded_options[:port]).to eq(80)
-      expect(expanded_options[:path]).to eq('/')
-    end
-
-    it "should add the default proxy settings" do
-      options = {:host => 'example.com'}
-      expanded_options = subject.expand_options(options)
-
-      expect(expanded_options[:proxy]).to eq(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)
-
-      expect(expanded_options[:proxy][:host]).to be_nil
-      expect(expanded_options[:proxy][:port]).to 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)
-
-      expect(expanded_options[:proxy]).to eq(proxy)
-    end
-
-    it "should parse the :proxy option" do
-      options = {:host => 'example.com', :proxy => 'http://proxy.com:8181'}
-      expanded_options = subject.expand_options(options)
-
-      expect(expanded_options[:proxy][:host]).to eq('proxy.com')
-      expect(expanded_options[:proxy][:port]).to eq(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)
-
-      expect(expanded_options[:url]).to be_nil
-      expect(expanded_options[:host]).to eq('example.com')
-      expect(expanded_options[:port]).to eq(8080)
-      expect(expanded_options[:user]).to eq('joe')
-      expect(expanded_options[:password]).to eq('secret')
-      expect(expanded_options[:path]).to eq('/bla')
-      expect(expanded_options[:query]).to eq('var')
-    end
-  end
-
-  describe "headers" do
-    it "should convert Symbol options to HTTP Headers" do
-      options = {:user_agent => 'bla', :location => 'test'}
-
-      expect(subject.headers(options)).to eq({
-        'User-Agent' => 'bla',
-        'Location'   => 'test'
-      })
-    end
-
-    it "should convert String options to HTTP Headers" do
-      options = {'user_agent' => 'bla', 'x-powered-by' => 'PHP'}
-
-      expect(subject.headers(options)).to eq({
-        '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}
-
-      expect(subject.headers(options)).to eq({
-        'Modified-By' => mtime.to_s,
-        'X-Accept'    => 'gzip'
-      })
-    end
-  end
-
-  describe "request" do
-    it "should handle Symbol names" do
-      expect(subject.request(
-        :method => :get, :path => '/'
-      ).class).to eq(Net::HTTP::Get)
-    end
-
-    it "should handle String names" do
-      expect(subject.request(
-        :method => 'GET', :path => '/'
-      ).class).to eq(Net::HTTP::Get)
-    end
-
-    context "with :path" do
-      it "should use a default path" do
-        expect {
-          subject.request(:method => :get)
-        }.not_to raise_error
-      end
-
-      it "should set the path" do
-        req = subject.request(:method => :get, :path => '/foo')
-
-        expect(req.path).to eq('/foo')
-      end
-    end
-
-    context "with :query" do
-      let(:path)  { '/foo' }
-      let(:query) { 'q=1' }
-
-      it "should append the query-string to the path" do
-        req = subject.request(
-          :method => :get,
-          :path   => path,
-          :query  => query
-        )
-
-        expect(req.path).to eq("#{path}?#{query}")
-      end
-
-      context "when path already contains a query string" do
-        let(:additional_query) { 'x=2' }
-
-        it "should append the query using a '&' character" do
-          req = subject.request(
-            :method => :get,
-            :path   => "#{path}?#{query}",
-            :query  => additional_query
-          )
-
-          expect(req.path).to eq("#{path}?#{query}&#{additional_query}")
-        end
-
-        context "when :query is empty" do
-          it "should append an extra '&'" do
-            req = subject.request(
-              :method => :get,
-              :path   => "#{path}?#{query}",
-              :query  => ''
-            )
-
-            expect(req.path).to be_end_with('&')
-          end
-        end
-      end
-
-      context "when :query is empty" do
-        it "should append an extra '?'" do
-          req = subject.request(
-            :method => :get,
-            :path   => path,
-            :query  => ''
-          )
-
-          expect(req.path).to be_end_with('?')
-        end
-      end
-    end
-
-    context "with :user and :password" do
-      it "should accept the :user option for Basic-Auth" do
-        req = subject.request(:method => :get, :user => 'joe')
-
-        expect(req['authorization']).to eq("Basic am9lOg==")
-      end
-
-      it "should also accept the :password options for Basic-Auth" do
-        req = subject.request(
-          :method => :get,
-          :user => 'joe',
-          :password => 'secret'
-        )
-
-        expect(req['authorization']).to eq("Basic am9lOnNlY3JldA==")
-      end
-    end
-
-    context "with :method" do
-      it "should create HTTP Copy requests" do
-        req = subject.request(:method => :copy)
-
-        expect(req.class).to eq(Net::HTTP::Copy)
-      end
-
-      it "should create HTTP Delete requests" do
-        req = subject.request(:method => :delete)
-
-        expect(req.class).to eq(Net::HTTP::Delete)
-      end
-
-      it "should create HTTP Get requests" do
-        req = subject.request(:method => :get)
-
-        expect(req.class).to eq(Net::HTTP::Get)
-      end
-
-      it "should create HTTP Head requests" do
-        req = subject.request(:method => :head)
-
-        expect(req.class).to eq(Net::HTTP::Head)
-      end
-
-      it "should create HTTP Lock requests" do
-        req = subject.request(:method => :lock)
-
-        expect(req.class).to eq(Net::HTTP::Lock)
-      end
-
-      it "should create HTTP Mkcol requests" do
-        req = subject.request(:method => :mkcol)
-
-        expect(req.class).to eq(Net::HTTP::Mkcol)
-      end
-
-      it "should create HTTP Move requests" do
-        req = subject.request(:method => :move)
-
-        expect(req.class).to eq(Net::HTTP::Move)
-      end
-
-      it "should create HTTP Options requests" do
-        req = subject.request(:method => :options)
-
-        expect(req.class).to eq(Net::HTTP::Options)
-      end
-
-      it "should create HTTP Post requests" do
-        req = subject.request(:method => :post)
-
-        expect(req.class).to eq(Net::HTTP::Post)
-      end
-
-      it "should create HTTP Propfind requests" do
-        req = subject.request(:method => :propfind)
-
-        expect(req.class).to eq(Net::HTTP::Propfind)
-      end
-
-      it "should create HTTP Proppatch requests" do
-        req = subject.request(:method => :proppatch)
-
-        expect(req.class).to eq(Net::HTTP::Proppatch)
-      end
-
-      it "should create HTTP Trace requests" do
-        req = subject.request(:method => :trace)
-
-        expect(req.class).to eq(Net::HTTP::Trace)
-      end
-
-      it "should create HTTP Unlock requests" do
-        req = subject.request(:method => :unlock)
-
-        expect(req.class).to eq(Net::HTTP::Unlock)
-      end
-
-      it "should raise an UnknownRequest exception for invalid methods" do
-        expect {
-          subject.request(:method => :bla)
-        }.to raise_error(subject::UnknownRequest)
-      end
-    end
-
-    it "should raise an ArgumentError when :method is not specified" do
-      expect {
-        subject.request()
-      }.to 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)
-        
-        expect(http).to be_kind_of(Net::HTTP)
-        expect(http).to 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
-
-        expect(http).to 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
-
-        expect(expanded_options[:host]).to eq(host)
-        expect(expanded_options[:port]).to eq(port)
-        expect(expanded_options[:path]).to eq(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
-        
-        expect(http).to be_kind_of(Net::HTTP)
-        expect(http).not_to be_started
-      end
-
-      it "should allow yielding the Net::HTTP session" do
-        http = nil
-
-        subject.http_session(:url => uri) do |session|
-          http = session
-        end
-        
-        expect(http).to 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
-
-        expect(expanded_options[:host]).to eq(host)
-        expect(expanded_options[:port]).to eq(port)
-        expect(expanded_options[:path]).to eq(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)
-
-        expect(response).to 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
-
-        expect(request).to 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
-        
-        expect(expanded_options[:host]).to eq(host)
-        expect(expanded_options[:port]).to eq(port)
-        expect(expanded_options[:path]).to eq(path)
-      end
-    end
-
-    describe "#http_status" do
-      it "should return an Integer" do
-        expect(subject.http_status(:url => uri)).to be_kind_of(Integer)
-      end
-
-      it "should return the status-code of the Response" do
-        expect(subject.http_status(:url => uri)).to eq(200)
-      end
-    end
-
-    describe "#http_ok?" do
-      it "should check if the Response has code 200" do
-        expect(subject.http_ok?(:url => uri)).to be(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
-        expect(subject.http_server(:url => url)).to eq(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
-        expect(subject.http_powered_by(:url => url)).to eq(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
-        expect(headers).not_to 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 }
-
-        expect(bad_headers).to eq([])
-      end
-    end
-
-    describe "#http_get_body" do
-      it "should return the response body" do
-        body = subject.http_get_body(:url => uri)
-
-        expect(body).to be_kind_of(String)
-        expect(body).not_to be_empty
-      end
-    end
-
-    describe "#http_post_headers" do
-      let(:headers) { subject.http_post_headers(:url => uri) }
-
-      it "should return HTTP Headers" do
-        expect(headers).not_to 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 }
-
-        expect(bad_headers).to eq([])
-      end
-    end
-
-    describe "#http_post_body" do
-      it "should return the response body" do
-        body = subject.http_post_body(:url => uri)
-
-        expect(body).to be_kind_of(String)
-        expect(body).not_to 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')
-
-      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')
-
-      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')
-
-      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')
-
-      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')
-
-      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
-
-  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)
-
-      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)
-
-      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)
-
-      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)
-
-      expect(proxy.host).to eq(host)
-      expect(proxy.port).to eq(port)
-    end
-
-    it "should accept nil" do
-      proxy = subject.create(nil)
-
-      expect(proxy).not_to be_enabled
-    end
-  end
-
-  it "should behave like a Hash" do
-    subject[:host] = 'example.com'
-    expect(subject[:host]).to eq('example.com')
-  end
-
-  it "should not have a host by default" do
-    expect(subject.host).to be_nil
-  end
-
-  it "should not have a port by default" do
-    expect(subject.port).to be_nil
-  end
-
-  it "should be disabled by default" do
-    expect(subject).not_to 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!
-
-    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
-    subject[:host] = 'example.com'
-    subject[:port] = 9001
-    subject[:user] = 'joe'
-    subject[:password] = 'lol'
-
-    url = subject.url
-
-    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
-    expect(subject.url).to be_nil
-  end
-
-  it "should return the host-name when converted to a String" do
-    subject[:host] = 'example.com'
-    expect(subject.to_s).to eq('example.com')
-  end
-
-  it "should return an empty String when there is no host-name" do
-    expect(subject.to_s).to 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
-    expect(subject.ip).not_to be_nil
-  end
-end