mosquito 0.1.2 → 0.1.3

data/test/sage_advice_cases/parsing_arrays.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'camping'
+
+Camping.goes :ParsingArrays
+
+class ParsingArrays::Controllers::Klonk < ParsingArrays::Controllers::R('/')
+  def get; render :foam; end
+  def post;  input.inspect; end
+end
+
+module ParsingArrays::Views
+  def foam
+    h2 "This is multipart with arrays"
+    form(:method => :post, :enctype => 'multipart/form-data') { _inputs }
+    h2 "This is urlencoded with arrays"
+    form(:method => :post, :enctype => 'application/x-www-form-urlencoded') { _inputs }
+  end
+  
+  def _inputs
+    input :type => :text, :name => "array", :value => '1'
+    input :type => :text, :name => "array", :value => '2'
+    input :type => :text, :name => "array", :value => '3'
+    input :type => :submit, :name => 'flush', :value => 'Observe'
+  end
+end

data/test/test_bare.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../lib/mosquito"
+require File.dirname(__FILE__) + "/../public/bare"
+
+# When you got a few Camping apps in one process you actually install the session
+# for all of them simply by including. We want to test operation without sessions so we
+# call this app Bare, which comes before Blog.
+class TestBare < Camping::FunctionalTest
+
+  test "should get index with success" do
+    get '/'
+    assert_response :success
+    assert_no_session
+    assert_match_body %r!Charles!
+  end
+
+  def test_get_without_arguments_should_give_us_the_index_page
+    get
+    assert_response :success
+    assert_match_body %r!Charles!
+  end
+
+  test "should get page with success" do
+    get '/sample'
+    assert_response :success
+    assert_no_session
+    assert_match_body %r!<p>A sample page</p>!
+  end
+
+  def test_request_uri_preserves_query_vars
+    get '/sample', :somevar => 10
+    assert_equal '/bare/sample?somevar=10', @request['REQUEST_URI']
+  end
+
+  test "should assert_no_match_body" do
+    get '/sample'
+    assert_no_match_body /Rubber\s+Bubblegum\s+Burt Reynolds\s+Hippopotamus/
+  end
+
+  test "should return error" do
+    get '/error'
+    assert_response :error
+  end
+
+  test "should return 404 error" do
+    get '/error404'
+    assert_response 404
+  end
+
+  def test_assigning_verbatim_post_payload
+    post '/sample', 'foo=bar&plain=flat'
+    @request.body.rewind
+    assert_equal 'foo=bar&plain=flat', @request.body.read
+  end
+
+  test "should redirect" do
+    get '/redirect'
+    assert_redirected_to '/faq'
+  end
+
+  # test "should send file" do
+  #   get '/file'
+  #   assert_response :success
+  #   # TODO
+  # end
+
+end

data/test/test_blog.rb

@@ -1,31 +1,51 @@
 require File.dirname(__FILE__) + "/../lib/mosquito"
 require File.dirname(__FILE__) + "/../public/blog"
-
 Blog.create
 include Blog::Models
 
 class TestBlog < Camping::FunctionalTest
-
   fixtures :blog_posts, :blog_users, :blog_comments
-  
+
   def setup
     super
-    # Do other stuff here
+    # We inject the session into the blog here to prevent it from attaching to Bare as well. Normally this
+    # should not happen but we need to take sides to test for sessioneless Camping compliance.
+    unless @sesion_set
+      Blog.send(:include, Camping::Session)
+      ActiveRecord::Migration.suppress_messages do
+        ::Camping::Models::Session.create_schema
+      end
+      @sesion_set = true
+    end
   end
-  
+
   def test_cookies
     get '/cookies'
-    assert_cookie 'awesome_cookie', 'camping+for+good'
+    assert_cookie 'awesome_cookie', 'camping for good'
+    assert_equal @state.awesome_data, 'camping for good'
+    get '/'
     assert_equal @state.awesome_data, 'camping for good'
+  end
+
+  def test_cookies_persisted_across_requests_and_escaping_properly_handled
+    @cookies["asgård"] = 'Wøbble'
+    get '/cookies'
+    assert_equal 'asgård=W%C3%B8bble', @request['HTTP_COOKIE'], "The cookie val shouldbe escaped"
+    assert_response :success
+    assert_equal 'Wøbble', @cookies["asgård"]
+
     get '/'
     assert_equal @state.awesome_data, 'camping for good'
+    assert_equal 'Wøbble', @cookies["asgård"]
   end
-  
+
   def test_index
     get
     assert_response :success
     assert_match_body %r!>blog<!
     assert_not_equal @state.awesome_data, 'camping for good'
+    assert_kind_of Array, @assigns[:posts]
+    assert_kind_of Post, assigns[:posts].first
   end
 
   def test_view
@@ -33,7 +53,7 @@ class TestBlog < Camping::FunctionalTest
     assert_response :success
     assert_match_body %r!The quick fox jumped over the lazy dog!
   end
-      
+
   def test_styles
     get 'styles.css'
     assert_match_body %r!Utopia!
@@ -52,20 +72,105 @@ class TestBlog < Camping::FunctionalTest
 
   def test_comment
     assert_difference(Comment) {
-      post 'comment', :post_username => 'jim', 
-                      :post_body => 'Nice article.', 
-                      :post_id => 1
+      post 'comment', {
+        :post_username => 'jim',
+        :post_body => 'Nice article.',
+        :post_id => 1
+      }
       assert_response :redirect
       assert_redirected_to '/view/1'
     }
   end
 
+  def test_sage_advice_raised_when_getting_with_files
+    assert_raise(Mosquito::SageAdvice) do
+      get '/view/1', :afile => Mosquito::MockUpload.new("apic.jpg")
+    end
+  end
+
+  def test_session_roundtrip_across_successive_requests
+    get '/session-roundtrip'
+    assert @state.has_key?(:flag_in_session)
+
+    assert_session_started
+    post '/session-roundtrip'
+    assert @state.has_key?(:second_flag), "The :second_flag key in the session gets set only if the previous flag was present"
+    assert_session_started
+  end
+
+  def test_request_uri_has_no_double_slashes
+    get '/session-roundtrip'
+    assert_equal "/blog/session-roundtrip", @request['REQUEST_URI']
+  end
+
+  def test_follow_redirect
+    get '/redirector'
+    assert_response :redirect
+
+    assert_redirected_to '/sniffer?one=two'
+
+    follow_redirect
+    roundtipped_params = YAML::load(StringIO.new(@response.body))
+    ref = {"one" => "two"}.with_indifferent_access
+    assert_equal ref, roundtipped_params
+  end
+
+  def test_request_honors_verbatim_query_string_and_passed_params
+    assert_nothing_raised do
+      get '/sniffer?one=2&foo=baz', :taing => 44
+    end
+
+    roundtripped = YAML::load(StringIO.new(@response.body.to_s))
+    ref = {"taing"=>"44", "one" => "2", "foo" => "baz"}
+    assert_equal ref, roundtripped
+  end
+
+  def test_uplaod_gets_a_quick_uplaod_handle
+    file = upload("pic.jpg")
+    assert_kind_of Mosquito::MockUpload, file
+  end
+
+  def test_intrinsic_methods
+    # This WILL use mocks when we get to it from more pressing matters
+    delete '/rest'
+    assert_equal 'Called delete', @response.body
+
+    put '/rest'
+    assert_equal 'Called put', @response.body
+  end
+
+  def calling_with_an_absolute_url_should_relativize
+    assert_equal 'test.host', @request.domain
+    put 'http://test.host/blog/rest'
+    assert_nothing_raised do
+      assert_equal 'Called put', @response.body
+    end
+  end
+
+  def test_calling_with_an_absolute_url_outside_of_the_default_test_host_must_raise
+    assert_equal 'test.host', @request.domain
+    assert_raise(Mosquito::NonLocalRequest) do
+      put 'http://yahoo.com/blog/rest'
+    end
+  end
+
+  def test_calling_with_an_absolute_url_outside_of_the_custom_test_host_must_raise
+    @request.domain = 'foo.bar'
+    assert_raise(Mosquito::NonLocalRequest) do
+      put 'http://test.host/blog/rest'
+    end
+  end
+
 end
 
-class TestPost < Camping::UnitTest
+class TestPost < Camping::ModelTest
 
   fixtures :blog_posts, :blog_users, :blog_comments
-      
+
+  def test_fixtures_path_is_relative_to_the_testcase
+    assert_equal 'test/fixtures/', self.class.fixture_path
+  end
+
   def test_create
     post = create
     assert post.valid?
@@ -83,19 +188,21 @@ class TestPost < Camping::UnitTest
     assert_equal original_count - 1, Post.count
   end
 
-private
+  private
 
   def create(options={})
-    Post.create({ :user_id => 1, 
-                  :title => "Title", 
-                  :body => "Body"}.merge(options))
+    Post.create({
+      :user_id => 1,
+      :title => "Title",
+      :body => "Body"
+    }.merge(options))
   end
-    
+
 end
 
-class TestUser < Camping::UnitTest
+class TestUser < Camping::ModelTest
 
-  fixtures :blog_posts, :blog_users, :blog_comments  
+  fixtures :blog_posts, :blog_users, :blog_comments
 
   def test_create
     user = create
@@ -108,12 +215,19 @@ class TestUser < Camping::UnitTest
     assert_not_nil user.errors.on(:username)
   end
 
-private
-  
+  test "should require username" do
+    assert_no_difference(User, :count) do
+      User.create(:username => nil)
+    end
+  end
+
+  private
+
   def create(options={})
-    User.create({ :username => 'godfrey', 
-                  :password => 'password' }.merge(options))
+    User.create({
+      :username => 'godfrey',
+      :password => 'password'
+    }.merge(options))
   end
-  
-end
 
+end

data/test/test_helpers.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../lib/mosquito"
+
+class TestHelpers < Camping::ModelTest
+  # http://rubyforge.org/tracker/index.php?func=detail&aid=8921&group_id=351&atid=1416
+  def test_supports_old_style_and_new_style_fixture_generation
+    assert self.respond_to?(:create_fixtures), "Oldstyle method should work"
+    assert self.class.respond_to?(:fixtures), "Newstyle method should work"
+  end
+  
+  def test_stash_and_unstash
+    someval = {:foo => "bar"}
+    assert_nothing_raised do
+      assert_equal someval, Mosquito::stash(someval)
+    end
+    
+    retr = Mosquito.unstash
+    assert_nil Mosquito.unstash, "There is nothing stashed now"
+    assert_equal retr, someval, "The value should be retrieved"
+  end
+end

data/test/test_mock_request.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + "/../lib/mosquito"
+
+$KCODE = 'u'
+# Sadly, Camping does not mandate UTF-8 - but we will use it here to torment the 
+# URL-escaping routines wïs ze ümlåuts.
+
+# We use Sniffer to check if our request is parsed properly. After being called Sniffer
+# will raise a Messenger exception with the @input inside.
+Camping.goes :Sniffer
+class Sniffer::Controllers::ParamPeeker < Sniffer::Controllers::R('/')
+  class Messenger < RuntimeError
+    attr_reader :packet
+    def initialize(packet)
+      @packet = packet
+    end
+  end
+  
+  def post
+    raise Messenger.new(input.dup)
+  end
+  alias_method :get, :post
+end
+
+class Sniffer::Controllers::ServerError
+  def get(*a)
+    raise a.pop
+  end
+end
+  
+class TestMockRequest < Test::Unit::TestCase
+  include Mosquito
+  
+  def setup
+    @parsed_input = nil
+    @req = MockRequest.new
+  end
+  
+  def test_default_domain_and_port
+    assert_equal 'test.host', @req.to_hash['SERVER_NAME']
+    assert_equal 'test.host', @req.to_hash['HTTP_HOST']
+  end
+
+  def test_envars_translate_to_readers
+    %w( server_name path_info accept_encoding user_agent 
+    script_name server_protocol cache_control accept_language
+    host remote_addr server_software keep_alive referer accept_charset
+    version request_uri server_port gateway_interface accept connection 
+    request_method).map do | envar  |
+      true_value = (@req[envar.upcase] || @req["HTTP_" + envar.upcase])
+      assert_not_nil true_value,
+        "The environment of the default request should provide #{envar.upcase} or HTTP_#{envar.upcase}"
+      assert_nothing_raised do
+        assert_equal true_value, @req.send(envar), "The request should understand the reader for #{envar}"
+        assert_equal true_value, @req.send(envar.upcase), "The request should understand the reader for #{envar.upcase} " +
+          "for backwards compatibility"
+      end
+    end
+  end
+  
+  def test_accessor_for_query_string
+    assert @req.respond_to?(:query_string), "The request must have a reader for query string"
+    assert @req.respond_to?(:query_string=), "The request must have a writer for query string"
+    
+    qs = "one=two&foo=bar"
+    assert_nothing_raised { @req.query_string = qs }
+    assert_equal "?one=two&foo=bar", @req.query_string,
+      "The request should return the query string segment with a question mark"
+    
+    qs = "?one=two&foo=bar"
+    assert_equal "?one=two&foo=bar", @req.query_string, 
+      "The request should return the query string segment with one and only one question mark"
+    
+    assert_equal '/?one=two&foo=bar', @req['REQUEST_URI'],
+      "The assigned query string should be propargated to REQUEST_URI"
+
+    assert_equal 'one=two&foo=bar', @req['QUERY_STRING'],
+      "The assigned query string should be propargated to QUERY_STRING"
+    
+    @req.query_string = ''
+    assert_equal '/', @req['REQUEST_URI'], "The query part should be removed from the REQUEST_URI along with the qmark"
+  end
+  
+  def test_query_string_composition_from_params
+    composable_hash = {
+      :foo => "bar",
+      :user => {
+        :login => "boss",
+        :password => "secret",
+        :friend_ids => [1, 2, 3]
+      }
+    }
+    
+    assert @req.respond_to?(:query_string_params=)
+    @req.query_string_params = composable_hash
+    
+    ref = '?foo=bar&user[friend_ids]=1&user[friend_ids]=2&user[friend_ids]=3&user[login]=boss&user[password]=secret'
+    assert_equal normalize_qs(ref), normalize_qs(@req.query_string)
+    assert_equal "/"+ref, @req['REQUEST_URI'], "The query string parameters should be propagated to the " + 
+      "request uri and be in their sorted form"
+    assert_equal normalize_qs(ref), normalize_qs(@req["QUERY_STRING"]), "The query string should also land in QUERY_STRING"
+  end
+  
+  def test_qs_assignment_with_empty_hash_unsets_envar
+    @req.query_string_params = {}
+    assert_equal '', @req.query_string, "When an empty hash is assigned the query string should be empty"
+    assert_nil @req.to_hash['QUERY_STRING'], "The key for QUERY_STRING should be unset in the environment"
+  end
+  
+  def test_multipart_boundary_generation
+    boundaries = (1..40).map do
+      @req.generate_boundary
+    end
+    assert_equal boundaries.uniq.length, boundaries.length, "All boundaries generated should be unique"
+    assert_equal boundaries, boundaries.grep(/^msqto\-/), "All boundaries should be prepended with msqto-"
+  end
+  
+  def test_method_missing_is_indeed_missing
+    assert_raise(NoMethodError) { @req.kaboodle! }
+  end
+  
+  def test_extract_values
+    t = {
+          :foo => "bar",
+          :bar => {
+            :baz => [1,2,3],
+            :bam => "trunk",
+          },
+          :sequence => "xyz"
+    }
+    assert_equal ["bar", "1", "2" , "3", "trunk", "xyz"].sort, @req.send(:extract_values, t).map(&:to_s).sort,
+      "should properly extract infinitely deeply nested values"
+  end
+  
+  def test_post_composition_with_urlencoding
+    assert_equal 'GET', @req['REQUEST_METHOD'], "The default request method is GET"
+
+    @req.post_params = {:hello => "welæcome", :name => "john", :data => {:values => [1,2,3] } }
+    assert_kind_of StringIO, @req.body, "The request body is an IO"
+    assert_equal 'POST', @req['REQUEST_METHOD'], 
+      "When the parameters are assigned the request should be switched to POST"
+    assert_equal "application/x-www-form-urlencoded", @req['CONTENT_TYPE'], 
+      "The content-type should be switched accordingly"
+    assert_equal normalize_qs('data[values]=1&data[values]=2&data[values]=3&hello=wel%C3%A6come&name=john'), normalize_qs(@req.body.read),
+      "The body should now contain URL-encoded form parameters"
+  end
+  
+  def test_post_composition_accepts_verbatim_strings_as_payload
+    assert_equal 'GET', @req['REQUEST_METHOD'], "The default request method is GET"
+    @req.post_params = 'foo=bar&baz=bad'
+    assert_equal 'POST', @req['REQUEST_METHOD']
+    assert_equal "application/x-www-form-urlencoded", @req['CONTENT_TYPE'], 
+      "The content-type should be switched accordingly"
+    assert_equal 'foo=bar&baz=bad', @req.body.read, "The payload should have been assigned directly"
+  end
+  
+  def test_append_to_query_string
+    @req.append_to_query_string "x=y&boo=2"
+    @req.append_to_query_string "zaz=taing&schmoo=tweed"
+    assert_equal "x=y&boo=2&zaz=taing&schmoo=tweed", @req["QUERY_STRING"]
+  end
+  
+  # We could let that one slip but why? If someone does TDD he deserves gratification
+  def test_post_composition_requiring_multipart_with_arrays_warns_the_noble_developer_and_everyone_stays_happy
+    assert_raise(Mosquito::SageAdvice) do
+      @req.post_params = {:hello => "welcome", :name => "john", :arrayed => [1, 2, 3], :somefile => MockUpload.new("pic.jpg") }
+    end
+    
+    assert_nothing_raised do
+      @req.post_params = {:hello => "welcome", :name => "john", :arrayed => [1, 2, 3], :not_a_file => "shtaink" }
+    end
+  end
+
+  # We could let that one slip but why? If someone does TDD he deserves gratification
+  def test_get_composition_with_files_warns_the_noble_developer_and_he_quickly_corrects_himself
+    assert_raise(Mosquito::SageAdvice) do
+      @req.query_string_params = {:hello => "welcome", :somefile => MockUpload.new("pic.jpg") }
+    end
+  end
+  
+  def test_post_composition_from_values_requiring_multipart
+    assert_equal 'GET', @req['REQUEST_METHOD'], "The default request method is GET"
+    
+    @req.post_params = {:hello => "welcome", :name => "john", :somefile => MockUpload.new("pic.jpg") }
+    
+    assert_kind_of StringIO, @req.body, "The request body is an IO"
+    assert_equal 'POST', @req['REQUEST_METHOD'], "When the parameters are assigned the request should be switched to POST"
+    ctype, boundary = @req['CONTENT_TYPE'].split(/=/)
+    boundary_with_prefix = "--" + boundary
+    assert_equal "multipart/form-data; boundary", ctype, "The content-type should be switched accordingly"
+    
+    @req.body.rewind
+    output = @req.body.read.split("\r")
+    ref_segments = [
+      "--#{boundary}", 
+      "\nContent-Disposition: form-data; name=\"hello\"", 
+      "\n", "\nwelcome", "\n--#{boundary}",
+      "\nContent-Disposition: form-data; name=\"name\"",
+      "\n",
+      "\njohn",
+      "\n--#{boundary}",
+      "\nContent-Disposition: form-data; name=\"somefile\"; filename=\"pic.jpg\"",
+      "\nContent-Type: image/jpeg", "\nContent-Length: 120",
+      "\n",
+      /\nStub file pic\.jpg \n([AZ-az]{120})\n/,
+      "\n--#{boundary}--"
+    ]
+
+    ref_segments.each_with_index do | ref, idx |
+      if ref == String
+        assert_equal ref, output[idx], "The segment #{idx} should be #{ref}"
+      elsif ref == Regexp
+        assert_match ref, output[idx], "The segment #{idx} should match #{ref}"
+      end
+    end    
+  end
+  
+  private
+    # Remove the question mark, sort the pairs
+    def normalize_qs(query_string)
+      "?" + query_string.to_s.gsub(/^\?/, '').split(/&/).sort.join('&')
+    end
+end
+
+
+class TestMockRequestWithRoundtrip < Test::Unit::TestCase
+  include Mosquito
+  def setup
+    @parsed_input = nil
+    @req = MockRequest.new
+  end
+
+  def test_multipart_post_properly_roundtripped
+    @req.post_params = {:hello => "welcome", :name => "john", :somefile => MockUpload.new("pic.jpg") }
+    
+    run_request!
+    
+    # Reference is something like this
+    # {"name"=>"john", "somefile"=>{"name"=>"somefile", "type"=>"image/jpeg",
+    # "tempfile"=>#<File:/tmp/C.9366.0>, "filename"=>"pic.jpg"}, "hello"=>"welcome"}
+
+    assert_equal "john", @parsed_input["name"]
+    assert_kind_of Hash, @parsed_input["somefile"]
+    assert_equal "somefile", @parsed_input["somefile"]["name"]
+    assert_equal "pic.jpg", @parsed_input["somefile"]["filename"]
+    assert_equal "image/jpeg", @parsed_input["somefile"]["type"]
+    assert_kind_of Tempfile, @parsed_input["somefile"]["tempfile"]
+    
+    
+    @req.post_params = {:hello => "welcome", :name => "john", :arrayed => [1, 2, 3], :somefile => "instead" }
+    assert_kind_of StringIO, @req.body, "The request body is an IO"
+    assert_match /urlencoded/, @req['CONTENT_TYPE'], "The ctype should have been switched back to urlencoded"
+    
+    run_request!
+    
+    ref = {"name"=>"john", "arrayed"=>["1", "2", "3"], "somefile"=>"instead", "hello"=>"welcome"}
+    assert_equal ref, @parsed_input, "Camping should have parsed our params just like so"
+  end
+  
+  def test_reader_and_writer_for_domain
+    assert_nothing_raised { assert_equal 'test.host', @req.domain }
+    assert_nothing_raised { @req.domain = "foo.dzing" }
+    
+    assert_equal 'foo.dzing', @req.domain 
+    assert_equal 'foo.dzing', @req['SERVER_NAME'] 
+    assert_equal 'foo.dzing', @req['HTTP_HOST'] 
+  end
+  
+  def test_query_string_properly_roundtripped
+    parsed = {"user"=> {"friend_äidéis"=>["1", "2", "3"], "paßwort"=>"secret", "login"=>"boss"}, "foo"=>"bar"}
+    @req.query_string_params = parsed
+    run_request!
+    assert_equal parsed, @parsed_input
+  end
+  
+  def test_urlencoded_post_properly_roundtripped
+    assert_equal 'GET', @req['REQUEST_METHOD'], "The default request method is GET"
+    
+    @req.post_params = {:hello => "welæcome", :name => "john", :data => {:values => [1,2,3] } }
+    run_request!
+    ref = {"name"=>"john", "hello"=>"welæcome", "data"=>{"values"=>["1", "2", "3"]}}
+    assert_equal ref, @parsed_input, "Camping should have parsed our input like so"
+  end
+  private
+    def run_request!
+      @req.body.rewind
+      begin
+        Sniffer.run(@req.body, @req.to_hash)
+      rescue Sniffer::Controllers::ParamPeeker::Messenger => e
+        @parsed_input = e.packet
+      end
+    end
+end