ronin-web 0.2.1 → 0.3.0.pre1

data/spec/web/middleware/proxy_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ronin/web/middleware/proxy'
+
+require 'web/helpers/rack_app'
+
+describe Web::Middleware::Proxy do
+  include Helpers::Web::RackApp
+
+  before(:all) do
+    self.app = Class.new(Sinatra::Base) do
+      use Ronin::Web::Middleware::Proxy, :path => '/login' do |proxy|
+        proxy.every_request do |request|
+          request.scheme = 'https'
+          request.host = 'github.com'
+          request.port = 443
+          request.referer = 'http://github.com/login'
+        end
+
+        proxy.every_response do |response|
+          response.body.each { |chunk| chunk.gsub!('https:','http:') }
+        end
+      end
+
+      get '/' do
+        'unproxied'
+      end
+
+      get '/login' do
+        'unproxied login'
+      end
+    end
+  end
+
+  it "should proxy requests that match the proxies filters" do
+    pending "http://github.com/brynary/rack-test/issues#issue/16" do
+      get '/login'
+
+      last_response.should be_ok
+      last_response.body.should_not == 'unproxied login'
+    end
+  end
+
+  it "should allow rewriting proxied requests" do
+    pending "http://github.com/brynary/rack-test/issues#issue/16" do
+      get '/login'
+
+      last_response.should be_ok
+      last_response.body.should include('Log in')
+    end
+  end
+
+  it "should allow rewriting proxied responses" do
+    pending "http://github.com/brynary/rack-test/issues#issue/16" do
+      get '/login'
+
+      last_response.should be_ok
+      last_response.body.should_not include('https:')
+    end
+  end
+
+  it "should still route un-matched requests to the app" do
+    get '/'
+
+    last_response.should be_ok
+    last_response.body.should == 'unproxied'
+  end
+end

data/spec/web/middleware/response_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'ronin/web/middleware/response'
+
+describe Web::Middleware::Response do
+  subject do
+    Web::Middleware::Response.new(
+      ['Hello'],
+      200,
+      {'Content-Type' => 'text/html'}
+    )
+  end
+
+  it "should allow implicit splatting" do
+    status, headers, body = subject
+
+    status.should == 200
+    headers['Content-Type'].should == 'text/html'
+    body.should == subject
+  end
+end

data/spec/web/middleware/router_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'ronin/web/middleware/router'
+
+require 'web/helpers/rack_app'
+
+describe Web::Middleware::Router do
+  include Helpers::Web::RackApp
+
+  before(:all) do
+    self.app = Class.new(Sinatra::Base) do
+      FakeApp = Class.new(Sinatra::Base) do
+
+        get '/test/1' do
+          'fake'
+        end
+
+        get '/test/2' do
+          'fake'
+        end
+
+      end
+
+      use Ronin::Web::Middleware::Router do |router|
+        router.draw :referer => /google\.com/, :to => FakeApp
+
+        router.draw :user_agent => /MSIE/,
+                    :referer => /myspace\.com/,
+                    :to => FakeApp
+      end
+
+      get '/test/1' do
+        'real'
+      end
+
+      get '/test/2' do
+        'real'
+      end
+
+    end
+  end
+
+  it "should route matched requests to other apps" do
+    get '/test/1', {}, {'HTTP_REFERER' => 'http://www.google.com/'}
+
+    last_response.should be_ok
+    last_response.body.should == 'fake'
+  end
+
+  it "should not route requests that do not match all rules" do
+    get '/test/2', {}, {
+      'HTTP_REFERER' => 'http://www.myspace.com/',
+      'HTTP_USER_AGENT' => 'Curl'
+    }
+
+    last_response.should be_ok
+    last_response.body.should_not == 'fake'
+  end
+
+  it "should still route un-matched requests to the app" do
+    get '/test/1'
+
+    last_response.should be_ok
+    last_response.body.should == 'real'
+  end
+end

data/spec/web/middleware/rule_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'ronin/web/middleware/rule'
+
+describe Web::Middleware::Rule do
+  subject { Web::Middleware::Rule }
+
+  before(:each) do
+    @request = mock('request')
+
+    @request.stub!(:host).and_return('www.example.com')
+    @request.stub!(:path).and_return('/path/sub/dir')
+  end
+
+  it "should match requests by default" do
+    rule = subject.new()
+
+    rule.match?(@request).should == true
+  end
+
+  it "should match requests against all filters" do
+    rule = subject.new(
+      :vhost => 'www.example.com',
+      :path => '/path/sub/dir'
+    )
+
+    rule.match?(@request).should == true
+  end
+
+  it "should match requests against against custom logic" do
+    rule = subject.new(
+      :path => '/path/sub/dir',
+      :when => lambda { |request| request.host =~ /example/ }
+    )
+
+    rule.match?(@request).should == true
+  end
+end

data/spec/web/proxy/base_spec.rb

@@ -1,6 +1,5 @@
-require 'ronin/web/proxy/base'
-
 require 'spec_helper'
+require 'ronin/web/proxy/base'
 
 describe Web::Proxy::Base do
   it "should run on a different port than Web::Server::Base" do

data/spec/web/server/base_spec.rb

@@ -1,25 +1,16 @@
+require 'spec_helper'
 require 'ronin/web/server/base'
 
-require 'spec_helper'
 require 'web/server/classes/test_app'
-require 'web/server/helpers/server'
+require 'web/helpers/rack_app'
 
 describe Web::Server::Base do
-  include Helpers::Web::Server
+  include Helpers::Web::RackApp
 
   before(:all) do
     self.app = TestApp
   end
 
-  it "should define a set of index file-names to search for" do
-    TestApp.indices.should == TestApp::DEFAULT_INDICES.to_set
-  end
-
-  it "should allow for defining new index file-names to search for" do
-    TestApp.index 'index.xml'
-    TestApp.indices.include?('index.xml').should == true
-  end
-
   it "should find a suitable Rack::Handler for the web server" do
     TestApp.handler_class.should_not be_nil
   end
@@ -63,7 +54,7 @@ describe Web::Server::Base do
     last_response.body.should == 'SubApp'
   end
 
-  it "should modify the path_info as it maps paths to sub-apps" do
+  it "should not modify the path_info as it maps paths to sub-apps" do
     get '/tests/subapp/hello'
 
     last_response.should be_ok

data/spec/web/server/classes/sub_app.rb

@@ -2,11 +2,11 @@ require 'ronin/web/server/base'
 
 class SubApp < Ronin::Web::Server::Base
 
-  get '/hello' do
+  get '/tests/subapp/hello' do
     'SubApp greets you'
   end
 
-  get '/' do
+  get '/tests/subapp/' do
     'SubApp'
   end
 

data/spec/web/server/classes/test_app.rb

@@ -12,7 +12,7 @@ class TestApp < Ronin::Web::Server::Base
     'any tested'
   end
 
-  map '/tests/subapp', SubApp
+  map '/tests/subapp/', SubApp
 
   public_dir File.join(File.dirname(__FILE__),'public1')
   public_dir File.join(File.dirname(__FILE__),'public2')

data/spec/web/web_spec.rb

@@ -1,8 +1,10 @@
-require 'ronin/web/web'
-
 require 'spec_helper'
+require 'ronin/web/web'
 
 describe Web do
+ let(:url) { 'http://ronin-ruby.github.com/' }
+ let(:title) { 'Ronin' }
+
   it "should have a VERSION constant" do
     Web.const_defined?('VERSION').should == true
   end
@@ -26,7 +28,7 @@ describe Web do
       }
     end
 
-    doc.to_html.include?("<html><body><div>hello</div></body></html>").should == true
+    doc.to_html.should include("<html><body><div>hello</div></body></html>")
   end
 
   it "should be able to parse XML" do
@@ -47,7 +49,7 @@ describe Web do
       }
     end
 
-    doc.to_xml.include?("<root>\n  <stuff name=\"bla\">hello</stuff>\n</root>").should == true
+    doc.to_xml.should include("<root>\n  <stuff name=\"bla\">hello</stuff>\n</root>")
   end
 
   it "should have a default proxy" do
@@ -58,30 +60,6 @@ describe Web do
     Web.proxy.should_not be_enabled
   end
 
-  describe "proxy_url" do
-    before(:all) do
-      @uri = URI('http://www.example.com:9001')
-    end
-
-    it "should convert Network::HTTP::Proxy objects into a URI" do
-      Web.proxy_url(Network::HTTP::Proxy.new(
-        :host => 'www.example.com',
-        :port => 9001
-      )).should == @uri
-    end
-
-    it "should convert a Hash into a URI" do
-      Web.proxy_url(
-        :host => 'www.example.com', 
-        :port => 9001
-      ).should == @uri
-    end
-
-    it "should convert a String into a valid URI" do
-      Web.proxy_url("www.example.com:9001").should == @uri
-    end
-  end
-
   it "should provide User-Agent aliases" do
     Web.user_agent_aliases.should_not be_empty
   end
@@ -93,75 +71,87 @@ describe Web do
   it "should allow setting of the User-Agent string using an alias" do
     Web.user_agent_alias = 'Mac FireFox'
 
-    Web.user_agent.should == "Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.3) Gecko/20060426 Firefox/1.5.0.3"
+    Web.user_agent.should == "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6"
   end
 
   it "should open URLs as temporary files" do
-    file = Web.open('http://www.example.com/')
+    file = Web.open(url)
     
-    file.read.should =~ /Example Web Page/
+    file.read.should include(title)
   end
 
   describe "agent" do
-    after(:each) do
-      Web.user_agent = nil
+    it "should provide Mechanize agents" do
+      Web.agent.class.should == Mechanize
     end
 
-    it "should provide WWW::Mechanize agents" do
-      Web.agent.class.should == WWW::Mechanize
-    end
+    describe ":user_agent" do
+      before(:all) do
+        Web.user_agent = 'test'
+      end
 
-    it "should use the Ronin User-Agent string" do
-      Web.user_agent = 'test'
-      Web.agent.user_agent.should == 'test'
-    end
+      it "should default to Web.user_agent" do
+        Web.agent.user_agent.should == 'test'
+      end
 
-    it "should support using a custom User-Agent string" do
-      agent = Web.agent(:user_agent => 'test2')
+      it "should support using a custom User-Agent string" do
+        agent = Web.agent(:user_agent => 'test2')
 
-      agent.user_agent.should == 'test2'
-    end
+        agent.user_agent.should == 'test2'
+      end
 
-    it "should support using a custom User-Agent alias" do
-      agent = Web.agent(:user_agent_alias => 'iPhone')
-      
-      agent.user_agent.should == 'Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1C28 Safari/419.3'
-    end
+      it "should support using a custom User-Agent alias" do
+        agent = Web.agent(:user_agent_alias => 'iPhone')
 
-    describe ":proxy" do
-      it "should accept Proxy values" do
-        pending "WWW::Mechanize needs reader methods for the proxy settings"
+        agent.user_agent.should == "Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1C28 Safari/419.3"
       end
 
-      it "should accept Hash values" do
+      after(:all) do
+        Web.user_agent = nil
       end
+    end
+
+    describe ":proxy" do
+      let(:host) { '127.0.0.1' }
+      let(:port) { 8080 }
 
-      it "should accept String values" do
-        pending "WWW::Mechanize needs reader methods for the proxy settings"
+      before(:all) do
+        Web.proxy = {:host => 'www.example.com', :port => port}
       end
 
       it "should default to Web.proxy" do
-        pending "WWW::Mechanize needs reader methods for the proxy settings"
+        agent = Web.agent
+
+        agent.proxy_addr.should == Web.proxy.host
+        agent.proxy_port.should == Web.proxy.port
+      end
+
+      it "should support using custom proxies" do
+        agent = Web.agent(:proxy => Network::HTTP::Proxy.new(
+          :host => host,
+          :port => port
+        ))
+
+        agent.proxy_addr.should == host
+        agent.proxy_port.should == port
       end
 
-      it "should raise a RuntimeError exception for bad :proxy options" do
-        lambda {
-          Web.agent(:proxy => 42)
-        }.should raise_error(RuntimeError)
+      after(:all) do
+        Web.proxy = nil
       end
     end
   end
 
-  it "should be able to get WWW::Mechanize pages" do
-    page = Web.get('http://www.example.com/')
+  it "should be able to get Mechanize pages" do
+    page = Web.get(url)
 
-    page.class.should == WWW::Mechanize::Page
-    page.at('title').inner_text.should == 'Example Web Page'
+    page.class.should == Mechanize::Page
+    page.at('title').inner_text.should include(title)
   end
 
-  it "should be able to get the bodies of WWW::Mechanize pages" do
-    body = Web.get_body('http://www.example.com/')
+  it "should be able to get the bodies of Mechanize pages" do
+    body = Web.get_body(url)
 
-    body.should =~ /Example Web Page/
+    body.should include(title)
   end
 end