nitro 0.31.0 → 0.40.0

data/test/nitro/helper/tc_table.rb

@@ -64,3 +64,5 @@ class TC_TableHelper < Test::Unit::TestCase # :nodoc: all
     assert_equal res, table
   end
 end
+
+

data/test/nitro/tc_cgi.rb

@@ -12,44 +12,97 @@ require 'nitro/cgi'
 require 'nitro/cgi/cookie'
 
 class String
-  class << self  
-    def random(size)
-      s = String.new
-      size.times {|i| s << (Kernel.rand(26)+25) } # ascii range
-      s
+  class << self
+
+    begin
+      require 'inline'
+
+      inline do |builder|
+        builder.c_raw <<-EOS
+          static VALUE rnd(int argc, VALUE* args, VALUE self)
+          {
+            if (!argc)
+              rb_raise(rb_eArgError, "not enough arguments");
+            if (argc > 0)
+              Check_Type(args[0], T_FIXNUM);
+            if (argc > 1)
+              Check_Type(args[1], T_FIXNUM);
+
+            int size = FIX2INT(args[0]);
+            int seed = argc > 1 ? FIX2INT(args[1]) : 0;
+            int i = 0;
+            VALUE str = rb_str_new((char*)0, size);
+
+            srandom(seed);
+
+            for (; i < size; i++) {
+              RSTRING(str)->ptr[i] = (char)(((random() % ('z' - ' ')) + ' '));
+            }
+
+            return str;
+          }
+        EOS
+      end
+
+      def random(size, seed = 22)
+        return rnd(size.to_i, seed.to_i)
+      end
+
+    rescue Exception => e
+      puts "please install Ruby::Inline (gem install RubyInline) to speed up this test"
+
+      def random(size)
+        s = String.new
+        range = (' '..'z').to_a
+        r_size = range.size
+        for i in (0...size)
+          s << range[Kernel.rand(r_size)] # ascii range
+        end
+        s
+      end
+
     end
+
   end
 end
 
 class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
   include Nitro
 
+  def test_rnd
+    size = 500
+    d = String.random(size)
+
+    assert_equal size, d.size
+    assert d.all? {|x| (' '..'z').include?(x) }, 'has to have ascii, had: ' + d.inspect
+  end
+
   class User 
     attr_accessor :name
     attr_accessor :password
   end
-     
+
   def test_parse_query_parameters
     qs = 'name=tml;id=12354'
     params = Cgi.parse_query_string(qs)
     assert_equal 2, params.size
     assert_equal 'tml', params['name']
-    
+
     qs = ''
     params = Cgi.parse_query_string(qs)
     assert_equal 0, params.size
-    
+
     qs = nil
     params = Cgi.parse_query_string(qs)
     assert_equal 0, params.size
-    
+
     qs = 'name=tml;arr[]=1;arr[]=2;arr[]=3'
     params = Cgi.parse_query_string(qs)
     assert_equal 2, params.size
     arr = params['arr']
     assert_equal Array, arr.class
     assert_equal 3, arr.size
-    
+
     qs = 'other=1;user.name=gmosx;user.password=hello'
     params = Cgi.parse_query_string(qs)
     assert_equal 2, params.size    
@@ -64,7 +117,7 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     assert_equal 'hello', user.password
 
     # Ruby/Scriptaculous compatibility.
-        
+
     qs = 'other=1;user[name]=gmosx;user[password]=hello'
     params = Cgi.parse_query_string(qs)
     assert_equal 2, params.size    
@@ -81,7 +134,7 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     Cgi.parse_cookies(context)
     assert_equal 2, context.cookies.size
     assert_equal '123', context.cookies['nsid']
-    
+
     context.env = {}
     context.env['HTTP_COOKIE'] = 'nsid=123; nsid=23123'
     cookies = Cgi.parse_cookies(context)
@@ -99,7 +152,7 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     ctx.response_headers = { 
       'Content-Type' => 'text/html' 
     }
- 
+
     res = "Status: 200 OK\r\nContent-Type: text/html\r\nSet-Cookie: nauthnauth=gmosx; Path=/\r\nSet-Cookie: nsidnsid=1233; Path=/\r\n\r\n"
     assert_equal res, Cgi.response_headers(ctx)
   end
@@ -118,7 +171,7 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     boundary = "---------------------------15773515131648678014689318540"
     closure = "#{Cgi::EOL}--#{boundary}--#{Cgi::EOL}"
     block_size = Cgi.buffer_size
-    
+
     input = StringIO.new
     input << "--#{boundary}#{Cgi::EOL}"
     input << "Content-Disposition: form-data; name=\"test_file_a\"; filename=\"test_case.txt\"#{Cgi::EOL}Content-Type: application/octet-stream#{Cgi::EOL}#{Cgi::EOL}"
@@ -126,13 +179,13 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     input << fake_file_a
     input_after_fake_file = input.size
     input << "#{Cgi::EOL}--#{boundary}#{Cgi::EOL}"
-    
+
     #Boundary fell inbetween two reads?
     assert_equal((block_size > input_after_fake_file) && (block_size < input.size),true)
-    
+
     input << "Content-Disposition: form-data; name=\"test_file_b\"; filename=\"test_case.txt\"#{Cgi::EOL}Content-Type: application/octet-stream#{Cgi::EOL}#{Cgi::EOL}"
     fake_file_b = Tempfile.new("TCCGI")
-    
+
     i = 0
     file_size = 1024*1024*10 # 10MB    
     i += fake_file_b.write String.random(1024*10) while i < file_size
@@ -148,12 +201,12 @@ class TestAdapterCgi < Test::Unit::TestCase # :nodoc: all
     start = Time.now
     params = Nitro::Cgi.parse_multipart(make_context(input), boundary)
     duration = Time.now - start
-#    puts "\nparse_multipart took: #{duration} seconds\n"
+    #    puts "\nparse_multipart took: #{duration} seconds\n"
     assert_equal(fake_file_a,params['test_file_a'].to_s)
     assert_equal(fake_file_b.read,params['test_file_b'].to_s)
     assert_equal(String.new,params['empty_field'].to_s)
   end
- 
+
 
   def make_context(input)
     context = OpenStruct.new

data/test/nitro/tc_controller.rb

@@ -9,13 +9,13 @@ require 'nitro'
 
 class TC_Controller < Test::Unit::TestCase # :nodoc: all
   include Nitro
-  
-  class Blog1Controller < Controller
+
+  class FirstController < Controller
     def list
     end
   end
 
-  class Blog2Controller < Controller
+  class SecondController < Controller
     attr_reader :aqflag, :tflag
 
     def self.setup_template_root(path)
@@ -25,70 +25,79 @@ class TC_Controller < Test::Unit::TestCase # :nodoc: all
     def list
       @aqflag = true 
     end
-    
+
     def another(oid)
-       # nop
+      # nop
     end
-    
-private
+
+    private
 
     def encode_myself
       encode_url :list
     end
 
-    def encode_blog1
-      encode_url Blog1Controller, :list
+    def encode_first
+      encode_url FirstController, :list
     end
   end
-  
+
   def setup
-    @disp = Dispatcher.new({
-      '/blog' => Blog2Controller,
-      '/blog1' => Blog1Controller                       
-    })
+    @disp = Dispatcher.new '/first'  => FirstController,
+                           '/second' => SecondController
     @conf = OpenStruct.new
     @conf.dispatcher = @disp
   end
-  
+
   def test_render
     ctx = Context.new(@conf)
     ctx.headers = {}
     ctx.params = {}
-    ctx.headers['REQUEST_URI'] = '/blog/list'
+    ctx.headers['REQUEST_URI'] = '/second/list'
     ctx.instance_eval '@session = {}'
     klass, action = ctx.dispatcher.dispatch(ctx.path, ctx)
     c = klass.new(ctx)
-    
+
     begin
       c.send(action)
     rescue RenderExit
       # drink
     end
 
-    assert_equal('/blog/list', c.send(:encode_myself))
-    assert_equal('/blog1/list', c.send(:encode_blog1))
+    assert_equal('/second/list', c.send(:encode_myself))
+    assert_equal('/first/list', c.send(:encode_first))
 
     # handle action with arity.
-    assert_equal('/blog/another/32', c.send(:encode_url, :another, :oid, 32))
+    assert_equal('/second/another/32', c.send(:encode_url, :another, :oid, 32))
 
     assert_equal true, c.aqflag
+=begin
+    # if anybody has an idea what this is for, go, fix it :)
     assert_equal true, $include1
     assert_equal true, $include2
 
     # the template is compiled
     assert_equal true, c.tflag
+=end
   end
 
   def test_action_methods
-    # aflag/tflag are counted too!
-#    p Blog2Controller.action_methods
-    # FIXME: the next 5 should be 3!!
-#    assert_equal 5, Blog2Controller.action_methods.size
-    assert Blog2Controller.action_methods.include?('list')
+    assert_equal ['list'], FirstController.action_methods
+    assert_equal 1, FirstController.action_methods.size
+    assert_equal 4, SecondController.action_methods.size
+    assert FirstController.action_methods.include?('list')
+    assert SecondController.action_methods.include?('list')
   end
 
   def test_encode_decode_methods
-    
+
+  end
+
+  def test_mount_path
+    assert_equal '/first', FirstController.mount_path
+    assert_equal '/second', SecondController.mount_path
+    # path is private
+    assert_equal '/first', FirstController.allocate.send(:mount_path)
+    assert_equal '/second', SecondController.allocate.send(:mount_path)
   end
 
 end

data/test/nitro/tc_controller_aspect.rb

@@ -22,6 +22,7 @@ class TestControllerAspect < Test::Unit::TestCase # :nodoc: all
   def test_aspect
     ctx = Context.new(Server.new)
     ctx.instance_variable_set '@session', {}
+    ctx.instance_variable_set '@headers', {}
     c = TestController.new(ctx)
     c.list_action
     

data/test/nitro/tc_controller_params.rb

@@ -0,0 +1,864 @@
+require File.join(File.dirname(__FILE__), 'CONFIG.rb')
+
+$DBG = true
+
+require 'test/unit'
+require 'ostruct'
+
+require 'nitro'
+require 'nitro/cgi'
+
+
+class String
+  def clear
+    gsub!(/.*/m, '')
+  end
+end
+
+class TC_ControllerParams < Test::Unit::TestCase # :nodoc: all
+  
+  module Common
+    def return_results *arguments
+      from = caller[0][/`.*?'/][1..-2].intern
+      hash = {}
+      request.params.each do |k,v|
+        hash[k] = if v.kind_of?(Tempfile) || v.kind_of?(StringIO) || v.kind_of?(IO)
+          { :filename => v.original_filename, :size => v.size }
+        else
+          v
+        end
+        request.params = hash
+      end
+      
+      @out.clear
+      @out << {
+        :action => from,
+        :params => request.params,
+        :arguments => arguments,
+        :klass => self.class,
+        :method => request.method
+      }.inspect
+    end
+    private :return_results
+  end # end module Common
+  
+  class TestController < Nitro::Controller
+    include Common
+    
+    def index
+      return_results
+    end
+    
+    # Arity 0
+    
+    def none
+      return_results
+    end
+    
+    # Arity 1 - 3
+
+    def single(arg)
+      return_results arg
+    end
+
+    def double(arg1, arg2)
+      return_results arg1, arg2
+    end
+
+    def triple(arg1, arg2, arg3)
+      return_results arg1, arg2, arg3
+    end
+    
+    def double__foo(arg)
+      return_results arg
+    end
+    
+    # Arity -1
+    
+    def m1(*args)
+      return_results *args
+    end
+    
+    def m1_2(arg1 = nil, arg2 = nil)
+      return_results arg1, arg2
+    end
+    
+    # Arity -2
+    
+    def m2(klass, parent_symbol = nil, parent_oid = nil, *args)
+      return_results klass, parent_symbol, parent_oid, args
+    end
+    
+    def m2_2(klass, parent_symbol = nil, parent_oid = nil)
+      return_results klass, parent_symbol, parent_oid
+    end
+    
+    # Overridden by C2?
+    
+    def c2
+      return_results
+    end
+    
+    # Error handler
+    
+    def error
+      "(error)"
+    end
+    
+  end # end class TestController
+  
+  class TestController2 < Nitro::Controller
+    include Common
+    
+    def index(arg1 = nil, arg2 = nil)
+      return_results arg1, arg2
+    end
+    
+  end # end class TestController2
+  
+  module TestTestController3Helper
+    def login
+      return_results
+    end
+  end
+  
+  class TestController3 < Nitro::Controller
+    include Common
+    include TestTestController3Helper
+    
+    def index(arg1)
+      return_results arg1
+    end
+    
+    def document(oid=nil, del=nil, add=nil)
+      return_results oid, del, add
+    end
+    
+    def post(one = nil)
+      return_results one
+    end
+    
+  end # end class TestController2
+  
+  
+  class TestControllerRouter < Nitro::Controller
+    include Common
+    
+    def routed_one(name)
+      return_results name
+    end
+    ::Nitro::Router.add_rule :match => /^\/routed_one\/(.*)/, :controller => TestControllerRouter, :action => :routed_one, :param => :name
+    
+  end
+  
+  #
+  # Defined assertions
+  #
+  
+  # Check against reference hash, only compare available values
+  
+  def cmp(reference, checked)
+    reference.each do |k,v|
+      return false if checked[k] != v
+    end
+    
+    return true
+  end
+  
+  def handle_request(url, value)
+    conf = OpenStruct.new
+    disp = Nitro::Dispatcher.new(
+      '/' => TestController, 
+      '/c2' => TestController2,
+      '/c3' => TestController3,
+      '/c4' => TestControllerRouter)
+    conf.dispatcher = disp
+    @ctx = Nitro::Context.new(conf)
+    @ctx.headers = { 'REQUEST_METHOD' => 'GET' }
+    @ctx.params = {}
+    @ctx.instance_variable_set '@session', {}
+    
+    if value[:in]
+      @ctx.in = value.delete(:in)
+      @ctx.headers['CONTENT_LENGTH'] = value.delete(:in_size) || @ctx.in.size
+    end
+    
+    if value[:method]
+      @ctx.headers['REQUEST_METHOD'] = value[:method].to_s
+    end
+    
+    if value['CONTENT_TYPE']
+      @ctx.headers['CONTENT_TYPE'] = value.delete('CONTENT_TYPE')
+    end
+    
+    @ctx.headers['REQUEST_URI'] = url
+    
+    if (!@ctx.query_string || @ctx.query_string.empty?) and @ctx.uri =~ /\?/
+      @ctx.headers['QUERY_STRING'] = @ctx.uri.split('?').last
+    end
+
+    Nitro::Cgi.parse_params(@ctx)
+    Nitro::Cgi.parse_cookies(@ctx)
+    
+    @ctx.render url
+
+    #retrieve the stuff from @out again as a hash
+    result = @ctx.out
+    
+    return result
+  end
+  
+  def assert_request_good(url, value, message = nil)
+    result = handle_request(url, value)
+    
+    message = build_message(message, "<?> returned error. \nResult: ?\nInstead of: ?", url, result, value)
+    
+    assert_block message do
+      if result =~ /error/
+        false
+      else
+        cmp(value, eval(result))
+      end
+    end
+  end
+  
+  def assert_request_bad(url, value, message = nil)
+    result = handle_request(url, value)
+    
+    message = build_message(message, '<?> did not return error.', url)
+    assert_block message do
+      result = @ctx.out
+      
+      result =~ /error/
+    end
+  end
+  
+  ###################################################################
+  #  Simple Testcases
+  ###################################################################
+
+  def test_simple
+    tests = {
+      '/none' => {
+        :action => :none,
+        :params => {},
+        :arguments => []
+      },
+      '/single/arg' => {
+        :action => :single,
+        :params => {},
+        :arguments => ['arg']
+      },
+      '/double/arg1/arg2' => {
+        :action => :double,
+        :params => {},
+        :arguments => ['arg1', 'arg2']
+      },
+      '/triple/arg1/arg2/arg3' => {
+        :action => :triple,
+        :params => {},
+        :arguments => ['arg1', 'arg2', 'arg3']
+      },
+      # George: none hase no arity, so the following *IS* valid!
+      '/none/one/two' => {
+        :action => :none,
+        :params => {},
+        :arguments => []
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+
+  def test_simple_params
+    tests = {
+      '/none/?first=one&second=two' => {
+        :action => :none,
+        :params => {'first' => 'one', 'second' => 'two'},
+        :arguments => []
+      },
+      '/none/?first=one&second=two' => {
+        :action => :none,
+        :params => {'first' => 'one', 'second' => 'two'},
+        :arguments => []
+      },
+      '/none/?first' => {
+        :action => :none,
+        :params => {'first' => nil},
+        :arguments => []
+      },
+      '/none/?first&second' => {
+        :action => :none,
+        :params => {'first' => nil, 'second' => nil},
+        :arguments => []
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+
+  def test_simple_bad
+    tests = {
+      '/single' => {
+        :action => :single,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Too few arguments. Should be one.'
+      },
+      '/double/arg1' => {
+        :action => :double,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Too few arguments. Should be two.'
+      },
+      '/triple/arg1/arg2' => {
+        :action => :triple,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Too few arguments. Should be 3.'
+      },
+      '/triple/arg1/arg2/arg3/arg4' => {
+        :action => :triple,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Too many arguments. Should be 3.'
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_bad url, value, value.delete(:errmsg)
+    end
+  end
+
+  def test_mixed
+    tests = {
+      '/single/foo?first=one&second=two' => {
+        :action => :single,
+        :params => {'first' => 'one', 'second' => 'two'},
+        :arguments => ['foo']
+      },
+      '/double/foo/bar?first=one&second=two' => {
+        :action => :double,
+        :params => {'first' => 'one', 'second' => 'two'},
+        :arguments => ['foo', 'bar']
+      }
+    }
+  
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+
+  def test_slashes
+    tests = {
+      '/single/foo' => {
+        :action => :single,
+        :params => {},
+        :arguments => ['foo']
+      },
+      '/double/foo/bar' => {
+        :action => :double__foo,
+        :params => {},
+        :arguments => []
+      },
+      '/double/foo/bar/' => {
+        :action => :double,
+        :params => {},
+        :arguments => ['foo', 'bar']
+      },
+      '/double/foo/bar' => {
+        :action => :double,
+        :params => {},
+        :arguments => ['foo', 'bar']
+      },
+      '/double/foo/bar/' => {
+        :action => :double,
+        :params => {},
+        :arguments => ['foo', 'bar']
+      },
+      '/none' => {
+        :action => :none,
+        :params => {},
+        :arguments => []
+      },
+      '/none/' => {
+        :action => :none,
+        :params => {},
+        :arguments => []
+      }
+    }
+  
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  ###################################################################
+  #  Arity -2 tests
+  ###################################################################
+
+  def test_m2
+    tests = {
+      '/m2/OgModule/user/5' => {
+        :action => :m2,
+        :params => {},
+        :arguments => ['OgModule', 'user', '5', []]
+      },
+      '/m2/OgModule' => {
+        :action => :m2,
+        :params => {},
+        :arguments => ['OgModule', nil, nil, []]
+      },
+      '/m2/OgModule/' => {
+        :action => :m2,
+        :params => {},
+        :arguments => ['OgModule', nil, nil, []]
+      },
+      '/m2/OgModule/user/5/more/garbage' => {
+        :action => :m2,
+        :params => {},
+        :arguments => ['OgModule', 'user', '5', ['more', 'garbage']]
+      },
+      '/m2_2/OgModule/user/5' => {
+        :action => :m2_2,
+        :params => {},
+        :arguments => ['OgModule', 'user', '5']
+      },
+      '/m2_2/OgModule' => {
+        :action => :m2_2,
+        :params => {},
+        :arguments => ['OgModule', nil, nil]
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  def test_m2_bad
+    tests = {
+      '/m2_2/OgModule/user/5/foo/bar' => {
+        :action => :m2_2,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Too many arguments.'
+      },
+      '/m2_2/' => {
+        :action => :m2_2,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Not enough arguments.'
+      },
+      '/m2' => {
+        :action => :m2,
+        :params => {},
+        :arguments => [],
+        :errmsg => 'Not enough arguments.'
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_bad url, value, value.delete(:errmsg)
+    end
+  end
+  
+  ###################################################################
+  #  Arity -1 Tests
+  ###################################################################
+  
+  def test_m1
+    tests = {
+      '/m1_2/' => {
+        :action => :m1_2,
+        :params => {},
+        :arguments => [nil, nil]
+      },
+      '/m1_2' => {
+        :action => :m1_2,
+        :params => {},
+        :arguments => [nil, nil]
+      },
+      '/m1_2/One' => {
+        :action => :m1_2,
+        :params => {},
+        :arguments => ['One', nil]
+      },
+      '/m1_2/One/Two' => {
+        :action => :m1_2,
+        :params => {},
+        :arguments => ['One', 'Two']
+      },
+    }
+
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  def test_sub_zero_mixed
+    tests = {
+      '/m1/OgModule/user/5?more=garbage' => {
+        :action => :m1,
+        :params => {'more' => 'garbage'},
+        :arguments => ['OgModule', 'user', '5']
+      },
+      '/m2/OgModule/user/5?more=garbage' => {
+        :action => :m2,
+        :params => {'more' => 'garbage'},
+        :arguments => ['OgModule', 'user', '5', []]
+      },
+      '/m2/OgModule?more=garbage' => {
+        :action => :m2,
+        :params => {'more' => 'garbage'},
+        :arguments => ['OgModule', nil, nil, []]
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  ###################################################################
+  #  Used Controller Tests
+  ###################################################################
+  
+  def test_controllers
+    tests = {
+      '/c2' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => [nil, nil]
+      },
+      '/c2/' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => [nil, nil]
+      },
+      '/' => {
+        :action => :index,
+        :klass => TestController
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  def test_index_handling
+    tests = {
+      '/c2/One' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => ['One', nil]
+      },
+      '/c2/One/Two' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => ['One', 'Two']
+      },
+      '/c2/index/One' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => ['One', nil]
+      },
+      '/c2/index/One/Two' => {
+        :action => :index,
+        :klass => TestController2,
+        :arguments => ['One', 'Two']
+      },
+      '/c3/index/One' => {
+        :action => :index,
+        :klass => TestController3,
+        :arguments => ['One']
+      },
+      '/c3/One' => {
+        :action => :index,
+        :klass => TestController3,
+        :arguments => ['One']
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  def test_index_handling_bad
+    tests = {
+      '/c2/One/Two/Three' => {
+        :action => :index,
+        :klass => TestController2
+      },
+      '/c2/index/One/Two/Three' => {
+        :action => :index,
+        :klass => TestController2
+      },
+      '/c3/One/Two' => {
+        :action => :index,
+        :klass => TestController3
+      },
+      '/c3' => {
+        :action => :index,
+        :klass => TestController3
+      },
+      '/c3/index' => {
+        :action => :index,
+        :klass => TestController3
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_bad url, value
+    end
+  end
+  
+  ###################################################################
+  #  Test Bug Reports
+  ###################################################################
+  
+  def test_bug_report_ray
+    tests = {
+      '/c3/document/new/1' => {
+        :action => :document,
+        :klass => TestController3,
+        :arguments => ['new', '1', nil]
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  def test_bug_report_fabian
+    tests = {
+      '/c3/login' => {
+        :action => :login,
+        :klass => TestController3,
+        :arguments => []
+      }
+    }
+    
+    assert TestController3.ancestors.include?(TestTestController3Helper)
+    assert TestController3.instance_methods.include?('login')
+    assert TestController3.action_methods.include?('login')
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+    
+  end
+  
+  ###################################################################
+  #  Test Routed Parameters
+  ###################################################################
+  
+  def test_routed_one
+    tests = {
+      '/routed_one/some/name/I/got/here...' => {
+        :action => :routed_one,
+        :klass => TestControllerRouter,
+        :arguments => ['some/name/I/got/here...'],
+        :params => {}
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  end
+  
+  ###################################################################
+  #  Mix-in GET Parameter Tests
+  ###################################################################
+  
+  def test_mixin_get_parameters
+    ::Nitro::Compiler.mixin_get_parameters = true
+    
+    tests = {
+      '/double?arg1=bar;arg2=foo' => {
+        :action => :double,
+        :params => {'arg1' => 'bar', 'arg2' => 'foo'},
+        :arguments => ['bar', 'foo']
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  ensure
+    ::Nitro::Compiler.mixin_get_parameters = false
+  end
+  
+  ###################################################################
+  #  Non-strict Action Calling Tests
+  ###################################################################
+  
+  def test_non_strict_action_calling
+    ::Nitro::Compiler.non_strict_action_calling = true
+    
+    tests = {
+      '/double' => {
+        :action => :double,
+        :params => {},
+        :arguments => [nil, nil]
+      }
+    }
+    
+    tests.each do |url, value|
+      assert_request_good url, value
+    end
+  ensure
+    ::Nitro::Compiler.non_strict_action_calling = false
+  end
+  
+  ###################################################################
+  #  Test POST Multipart
+  ###################################################################
+  
+  def test_multipart
+    tests = {
+      '/c3/post' => {
+        :action => :post,
+        :klass => TestController3,
+        :arguments => [nil],
+        :params => {"test_file_a" => {:size=>10028,
+                                      :filename=>"test_case.txt"},
+                    "test_file_b" => {:size=>10240,
+                                      :filename=>"test_case.txt"},
+                    "empty_field" => {:size=>0, :filename=>""}},
+        :method => :post
+      },
+      '/c3/post/1' => {
+        :action => :post,
+        :klass => TestController3,
+        :arguments => ['1'],
+        :params => {"test_file_a" => {:size=>10028,
+                                      :filename=>"test_case.txt"},
+                    "test_file_b" => {:size=>10240,
+                                      :filename=>"test_case.txt"},
+                    "empty_field" => {:size=>0, :filename=>""}},
+        :method => :post
+      },
+      '/c3/post/1?more=data' => {
+        :action => :post,
+        :klass => TestController3,
+        :arguments => ['1'],
+        :params => {"test_file_a" => {:size=>10028,
+                                      :filename=>"test_case.txt"},
+                    "test_file_b" => {:size=>10240,
+                                      :filename=>"test_case.txt"},
+                    "empty_field" => {:size=>0, :filename=>""},
+                    "more" => "data"},
+        :method => :post
+      }
+    }
+    
+    tests.each do |url, value|
+      create_multipart(value)
+      assert_request_good url, value
+    end
+  end
+
+  def create_multipart(options, boundary = "---------------------------15773515131648678014689318540")
+    # MIME block close falls on read boundary, also contains an empty field.
+    closure = "#{Nitro::Cgi::EOL}--#{boundary}--#{Nitro::Cgi::EOL}"
+    block_size = Nitro::Cgi.buffer_size
+
+    input = StringIO.new
+    input << "--#{boundary}#{Nitro::Cgi::EOL}"
+    input << "Content-Disposition: form-data; name=\"test_file_a\"; filename=\"test_case.txt\"#{Nitro::Cgi::EOL}Content-Type: application/octet-stream#{Nitro::Cgi::EOL}#{Nitro::Cgi::EOL}"
+    fake_file_a = String.random(block_size - input.size - (closure.size/2))
+    input << fake_file_a
+    input_after_fake_file = input.size
+    input << "#{Nitro::Cgi::EOL}--#{boundary}#{Nitro::Cgi::EOL}"
+
+    #Boundary fell inbetween two reads?
+    assert_equal((block_size > input_after_fake_file) && (block_size < input.size),true)
+
+    input << "Content-Disposition: form-data; name=\"test_file_b\"; filename=\"test_case.txt\"#{Nitro::Cgi::EOL}Content-Type: application/octet-stream#{Nitro::Cgi::EOL}#{Nitro::Cgi::EOL}"
+    fake_file_b = Tempfile.new("TCCGI")
+
+    i = 0
+    file_size = 1024*10 # 1MB    
+    i += fake_file_b.write String.random(1024*10) while i < file_size
+
+    fake_file_b.rewind
+    input << fake_file_b.read
+    fake_file_b.rewind
+    input << "#{Nitro::Cgi::EOL}--#{boundary}#{Nitro::Cgi::EOL}"
+
+    input << "Content-Disposition: form-data; name=\"empty_field\"#{Nitro::Cgi::EOL}#{Nitro::Cgi::EOL}"
+    input << closure
+    input.rewind
+    
+    options[:in] = input
+    options[:in_size] = input.size
+    options['CONTENT_TYPE'] = "multipart/form-data boundary=\"#{boundary}\""
+  end
+  
+end
+
+# Random data for multipart param test
+
+class String
+  class << self
+
+    begin
+      require 'inline'
+
+      inline do |builder|
+        builder.c_raw <<-EOS
+          static VALUE rnd(int argc, VALUE* args, VALUE self)
+          {
+            if (!argc)
+              rb_raise(rb_eArgError, "not enough arguments");
+            if (argc > 0)
+              Check_Type(args[0], T_FIXNUM);
+            if (argc > 1)
+              Check_Type(args[1], T_FIXNUM);
+
+            int size = FIX2INT(args[0]);
+            int seed = argc > 1 ? FIX2INT(args[1]) : 0;
+            int i = 0;
+            VALUE str = rb_str_new((char*)0, size);
+
+            srandom(seed);
+
+            for (; i < size; i++) {
+              RSTRING(str)->ptr[i] = (char)(((random() % ('z' - ' ')) + ' '));
+            }
+
+            return str;
+          }
+        EOS
+      end
+
+      def random(size, seed = 22)
+        return rnd(size.to_i, seed.to_i)
+      end
+
+    rescue Exception => e
+      puts "please install Ruby::Inline (gem install RubyInline) to speed up this test"
+
+      def random(size)
+        s = String.new
+        range = (' '..'z').to_a
+        r_size = range.size
+        for i in (0...size)
+          s << range[Kernel.rand(r_size)] # ascii range
+        end
+        s
+      end
+
+    end
+
+  end
+end