passenger 2.1.3 → 2.2.0

data/test/ScgiRequestParserTest.cpp

@@ -0,0 +1,337 @@
+#include "tut.h"
+#include "ScgiRequestParser.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct ScgiRequestParserTest {
+		ScgiRequestParser parser;
+	};
+	
+	DEFINE_TEST_GROUP(ScgiRequestParserTest);
+
+	TEST_METHOD(1) {
+		// It has an initial state of READING_LENGTH_STRING and does
+		// not have anything in its header data buffer.
+		ensure_equals(parser.getState(), ScgiRequestParser::READING_LENGTH_STRING);
+		ensure(parser.getHeaderData().empty());
+	}
+	
+	/***** Test parsing a complete SCGI request in a single pass. *****/
+	
+	TEST_METHOD(2) {
+		// Parsing a request with a single header and no body.
+		static const char data[] = "12:hello\0world\0,";
+		ensure_equals("It accepted all input.",
+			parser.feed(data, sizeof(data) - 1),
+			sizeof(data) - 1);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0", 12));
+		ensure(parser.getHeader("hello") == "world");
+	}
+	
+	TEST_METHOD(3) {
+		// Parsing a request with a single header and a body.
+		static const char data[] = "12:hello\0world\0,data";
+		ensure_equals("It accepted all input.",
+			parser.feed(data, sizeof(data) - 1 - 4),
+			sizeof(data) - 1 - 4);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0", 12));
+		ensure(parser.getHeader("hello") == "world");
+	}
+	
+	TEST_METHOD(4) {
+		// Parsing a request with multiple headers and no body.
+		static const char data[] = "19:hello\0world\0SCGI\0001\0,";
+		ensure_equals("It accepted all input.",
+			parser.feed(data, sizeof(data) - 1),
+			sizeof(data) - 1);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0SCGI\0001\0", 19));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("SCGI") == "1");
+	}
+	
+	TEST_METHOD(5) {
+		// Parsing a request with multiple headers and a body.
+		static const char data[] = "19:hello\0world\0SCGI\0001\0,body";
+		ensure_equals("It accepted all input.",
+			parser.feed(data, sizeof(data) - 1 - 4),
+			sizeof(data) - 1 - 4);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0SCGI\0001\0", 19));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("SCGI") == "1");
+	}
+	
+	/***** Test parsing a complete SCGI request in multiple passes. *****/
+	
+	TEST_METHOD(8) {
+		// Parsing a request with multiple headers and a body.
+		// 1 byte per pass.
+		static const char data[] = "20:hello\0world\0foo\0bar\0,data";
+		for (unsigned int i = 0; i < sizeof(data) - 1 - 4; i++) {
+			ensure_equals(parser.feed(&data[i], 1), 1u);
+		}
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0foo\0bar\0", 20));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("foo") == "bar");
+	}
+	
+	TEST_METHOD(9) {
+		// Parsing a request with multiple headers and a body.
+		// Half element per pass.
+		ensure_equals(parser.feed("2", 1), 1u);
+		ensure_equals(parser.feed("0", 1), 1u);
+		ensure_equals(parser.feed(":", 1), 1u);
+		ensure_equals(parser.feed("hello\0world\0", 12), 12u);
+		ensure_equals(parser.feed("foo\0bar\0", 8), 8u);
+		ensure_equals(parser.feed(",", 1), 1u);
+		ensure_equals(parser.feed("da", 2), 0u);
+		ensure_equals(parser.feed("ta", 2), 0u);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0foo\0bar\0", 20));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("foo") == "bar");
+	}
+	
+	TEST_METHOD(10) {
+		// Parsing a request with multiple headers and a body.
+		// 1 element per pass.
+		ensure_equals(parser.feed("20", 2), 2u);
+		ensure_equals(parser.feed(":", 1), 1u);
+		ensure_equals(parser.feed("hello\0world\0foo\0bar\0", 20), 20u);
+		ensure_equals(parser.feed(",", 1), 1u);
+		ensure_equals(parser.feed("data", 4), 0u);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0foo\0bar\0", 20));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("foo") == "bar");
+	}
+	
+	TEST_METHOD(11) {
+		// Parsing a request with multiple headers and a body.
+		// 2 elements per pass.
+		ensure_equals(parser.feed("20:", 3), 3u);
+		ensure_equals(parser.feed("hello\0world\0foo\0bar\0,", 21), 21u);
+		ensure_equals(parser.feed("data", 4), 0u);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0foo\0bar\0", 20));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("foo") == "bar");
+	}
+	
+	TEST_METHOD(12) {
+		// Parsing a request with multiple headers and a body.
+		// Variable number of elements per pass.
+		ensure_equals(parser.feed("20:h", 4), 4u);
+		ensure_equals(parser.feed("ello\0world\0foo\0bar", 18), 18u);
+		ensure_equals(parser.feed("\0,data", 6), 2u);
+		ensure_equals("It is in the accepting state.",
+			parser.getState(), ScgiRequestParser::DONE);
+		ensure_equals("It parsed the header data.",
+			parser.getHeaderData(),
+			string("hello\0world\0foo\0bar\0", 20));
+		ensure(parser.getHeader("hello") == "world");
+		ensure(parser.getHeader("foo") == "bar");
+	}
+	
+	/***** Test parsing invalid SCGI requests in one pass. *****/
+	
+	TEST_METHOD(16) {
+		// Invalid first character for length string.
+		ensure_equals("Parser did not accept anything.",
+			parser.feed("hello world!", 12), 0u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(17) {
+		// Invalid character inside length string.
+		ensure_equals(parser.feed("12x:hello world!", 16), 2u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(18) {
+		// Invalid character in place of colon.
+		ensure_equals(parser.feed("12#hello world!", 15), 2u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(19) {
+		// Invalid character in place of comma.
+		ensure_equals(parser.feed("12:hello\0world\0!", 16), 15u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(20) {
+		// Only a header name, without even a null terminator.
+		ensure_equals(parser.feed("5:hello,", 8), 7u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(21) {
+		// Only a header name, with a null terminator.
+		ensure_equals(parser.feed("6:hello\0,", 9), 8u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(22) {
+		// A header name with its value not having a null terminator.
+		ensure_equals(parser.feed("7:foo\0bar,", 10), 9u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(23) {
+		// A header name without corresponding value.
+		ensure_equals(parser.feed("10:foo\0bar\0a\0,", 14), 13u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(24) {
+		// Length string is too large.
+		static const char data[] = "999999999999999999999";
+		ensure(parser.feed(data, sizeof(data) - 1) < sizeof(data) - 1);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	/***** Test parsing invalid SCGI requests in multiple passes. *****/
+	
+	TEST_METHOD(27) {
+		// Once the parser has entered the error state, it stays there.
+		ensure_equals(parser.feed("hello world!", 12), 0u);
+		ensure_equals(parser.feed("1", 1), 0u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(28) {
+		// Invalid character inside length string.
+		ensure_equals(parser.feed("12", 2), 2u);
+		ensure_equals(parser.feed("x:", 2), 0u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(29) {
+		// Invalid character in place of colon.
+		ensure_equals(parser.feed("12", 2), 2u);
+		ensure_equals(parser.feed("#", 1), 0u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(30) {
+		// Invalid character in place of comma.
+		ensure_equals(parser.feed("12:hello\0world\0", 15), 15u);
+		ensure_equals(parser.feed("!", 1), 0u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(31) {
+		// Only a header name, without even a null terminator.
+		ensure_equals(parser.feed("5:hell", 6), 6u);
+		ensure_equals(parser.feed("o,", 1), 1u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(32) {
+		// Only a header name, with a null terminator.
+		ensure_equals(parser.feed("6:hello", 7), 7u);
+		ensure_equals(parser.feed("\0,", 1), 1u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(33) {
+		// A header name with its value not having a null terminator.
+		ensure_equals(parser.feed("7:foo\0ba", 8), 8u);
+		ensure_equals(parser.feed("r,", 2), 1u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(34) {
+		// A header name without corresponding value.
+		ensure_equals(parser.feed("10:foo\0bar\0a", 12), 12u);
+		ensure_equals(parser.feed("\0,", 2), 1u);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(35) {
+		// Length string is too large.
+		static const char data[] = "999999999999999999999";
+		ensure_equals(parser.feed("99", 2), 2u);
+		ensure(parser.feed(data, sizeof(data) - 1) < sizeof(data) - 1);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	/***** Test parsing incomplete SCGI requests. *****/
+	
+	TEST_METHOD(40) {
+		// Incomplete length string.
+		ensure_equals(parser.feed("2", 1), 1u);
+		ensure_equals("Parser is still waiting for length string input.",
+			parser.getState(), ScgiRequestParser::READING_LENGTH_STRING);
+	}
+	
+	TEST_METHOD(41) {
+		// Incomplete header.
+		ensure_equals(parser.feed("21:", 3), 3u);
+		ensure_equals("Parser is waiting for header data input.",
+			parser.getState(), ScgiRequestParser::READING_HEADER_DATA);
+	}
+	
+	TEST_METHOD(42) {
+		// Incomplete header.
+		ensure_equals(parser.feed("20:hel", 6), 6u);
+		ensure_equals("Parser is waiting for header data input.",
+			parser.getState(), ScgiRequestParser::READING_HEADER_DATA);
+	}
+	
+	TEST_METHOD(43) {
+		// Complete header but no comma.
+		ensure_equals(parser.feed("8:foo\0bar\0", 10), 10u);
+		ensure_equals("Parser is waiting for comma.",
+			parser.getState(), ScgiRequestParser::EXPECTING_COMMA);
+	}
+}

data/test/StaticStringTest.cpp

@@ -0,0 +1,51 @@
+#include "tut.h"
+#include "StaticString.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct StaticStringTest {
+	};
+	
+	DEFINE_TEST_GROUP(StaticStringTest);
+
+	TEST_METHOD(1) {
+		// Test == operator.
+		ensure(StaticString("") == "");
+		ensure(StaticString("foo") == "foo");
+		ensure(!(StaticString("foo") == "bar"));
+	}
+	
+	TEST_METHOD(2) {
+		// Test < operator.
+		ensure_equals("Assertion 1",
+			StaticString("") < "",
+			string("") < string("")
+		);
+		ensure_equals("Assertion 2",
+			StaticString("abc") < "abc",
+			string("abc") < string("abc")
+		);
+		ensure_equals("Assertion 3",
+			StaticString("foo") < "bar",
+			string("foo") < string("bar")
+		);
+		ensure_equals("Assertion 4",
+			StaticString("foo") < "bar!",
+			string("foo") < string("bar!")
+		);
+		ensure_equals("Assertion 5",
+			StaticString("bar!") < "foo",
+			string("bar!") < string("foo")
+		);
+		ensure_equals("Assertion 6",
+			StaticString("hello") < "hello world",
+			string("hello") < string("hello world")
+		);
+		ensure_equals("Assertion 7",
+			StaticString("hello world") < "hello",
+			string("hello world") < string("hello")
+		);
+	}
+}

data/test/UtilsTest.cpp

@@ -1,5 +1,6 @@
 #include "tut.h"
 #include "Utils.h"
+#include "support/Support.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdio.h>
@@ -10,6 +11,7 @@
 
 using namespace Passenger;
 using namespace std;
+using namespace Test;
 
 namespace tut {
 	struct UtilsTest {
@@ -245,4 +247,34 @@ namespace tut {
 		ensure_equals(escapeForXml("hello\xFF\xCCworld"), "hello&#255;&#204;world");
 		ensure_equals(escapeForXml("hello\xFFworld\xCC"), "hello&#255;world&#204;");
 	}
+	
+	/***** Test extractDirName() *****/
+	
+	TEST_METHOD(26) {
+		ensure_equals("Test 1", extractDirName("/usr/lib"), "/usr");
+		ensure_equals("Test 2", extractDirName("/usr/lib/"), "/usr");
+		ensure_equals("Test 3", extractDirName("/usr/"), "/");
+		ensure_equals("Test 4", extractDirName("usr"), ".");
+		ensure_equals("Test 5", extractDirName("/"), "/");
+		ensure_equals("Test 6", extractDirName("///"), "/");
+		ensure_equals("Test 7", extractDirName("."), ".");
+		ensure_equals("Test 8", extractDirName(".."), ".");
+		ensure_equals("Test 9", extractDirName("./foo"), ".");
+		ensure_equals("Test 10", extractDirName("../foo"), "..");
+	}
+	
+	/***** Test resolveSymlink() *****/
+	
+	TEST_METHOD(27) {
+		TempDir d("tmp.symlinks");
+		system("touch tmp.symlinks/foo.txt");
+		system("ln -s /usr/bin tmp.symlinks/absolute_symlink");
+		system("ln -s foo.txt tmp.symlinks/file");
+		system("ln -s file tmp.symlinks/file2");
+		system("ln -s file2 tmp.symlinks/file3");
+		ensure_equals(resolveSymlink("tmp.symlinks/file"), "tmp.symlinks/foo.txt");
+		ensure_equals(resolveSymlink("tmp.symlinks/file2"), "tmp.symlinks/file");
+		ensure_equals(resolveSymlink("tmp.symlinks/file3"), "tmp.symlinks/file2");
+		ensure_equals(resolveSymlink("tmp.symlinks/absolute_symlink"), "/usr/bin");
+	}
 }

data/test/config.yml.example

@@ -23,3 +23,8 @@ nonexistant_user: xxxxxxxxxxxxxxxxxxx
 # A nonexistant user ID.
 nonexistant_uid: 9999
 
+
+# If you want to run the Nginx integration tests, then set the following
+# config option to the full path of the Nginx binary. This Nginx binary *must*
+# be compiled with Phusion Passenger support!
+# nginx: /usr/local/sbin/nginx

data/test/{integration_tests.rb → integration_tests/apache2_tests.rb}

@@ -1,254 +1,17 @@
-require 'net/http'
-require 'uri'
-require 'resolv'
 require 'socket'
 require 'fileutils'
-require 'timeout'
 require 'support/config'
 require 'support/test_helper'
-require 'support/multipart'
 require 'support/apache2_controller'
 require 'phusion_passenger/platform_info'
 
+require 'integration_tests/mycook_spec'
+require 'integration_tests/hello_world_rack_spec'
+require 'integration_tests/hello_world_wsgi_spec'
+
 # TODO: test the 'RailsUserSwitching' and 'RailsDefaultUser' option.
 # TODO: test custom page caching directory
 
-shared_examples_for "MyCook(tm) beta" do
-	it "is possible to fetch static assets" do
-		get('/images/rails.png').should == public_file('images/rails.png')
-	end
-	
-	it "supports page caching on non-index URIs" do
-		get('/welcome/cached').should =~ %r{This is the cached version of /welcome/cached}
-	end
-	
-	it "supports page caching on index URIs" do
-		get('/uploads').should =~ %r{This is the cached version of /uploads}
-	end
-	
-	it "doesn't use page caching if the HTTP request is not GET" do
-		post('/welcome/cached').should =~ %r{This content should never be displayed}
-	end
-	
-	it "isn't interfered by Rails's default .htaccess dispatcher rules" do
-		get('/welcome/in_passenger').should == 'true'
-	end
-	
-	it "is possible to GET a regular Rails page" do
-		get('/').should =~ /Welcome to MyCook/
-	end
-	
-	it "is possible to pass GET parameters to a Rails page" do
-		result = get('/welcome/parameters_test?hello=world&recipe[name]=Green+Bananas')
-		result.should =~ %r{<hello>world</hello>}
-		result.should =~ %r{<recipe>}
-		result.should =~ %r{<name>Green Bananas</name>}
-	end
-	
-	it "is possible to POST to a Rails page" do
-		result = post('/recipes', {
-			'recipe[name]' => 'Banana Pancakes',
-			'recipe[instructions]' => 'Call 0900-BANANAPANCAKES'
-		})
-		result.should =~ %r{HTTP method: post}
-		result.should =~ %r{Name: Banana Pancakes}
-		result.should =~ %r{Instructions: Call 0900-BANANAPANCAKES}
-	end
-	
-	it "is possible to upload a file" do
-		rails_png = File.open("#{@stub.app_root}/public/images/rails.png", 'rb')
-		params = {
-			'upload[name1]' => 'Kotonoha',
-			'upload[name2]' => 'Sekai',
-			'upload[data]' => rails_png
-		}
-		begin
-			response = post('/uploads', params)
-			rails_png.rewind
-			response.should ==
-				"name 1 = Kotonoha\n" <<
-				"name 2 = Sekai\n" <<
-				"data = " << rails_png.read
-		ensure
-			rails_png.close
-		end
-	end
-	
-	it "can properly handle custom headers" do
-		response = get_response('/welcome/headers_test')
-		response["X-Foo"].should == "Bar"
-	end
-
-	it "supports %2f in URIs" do
-		get('/welcome/show_id/foo%2fbar').should == 'foo/bar'
-	end
-
-	it "has AbstractRequest which returns a request_uri without hostname, with query_string" do
-		get('/welcome/request_uri?foo=bar%20escaped').should =~ %r{/welcome/request_uri\?foo=bar%20escaped}
-	end
-
-	it "supports restarting via restart.txt" do
-		begin
-			controller = "#{@stub.app_root}/app/controllers/test_controller.rb"
-			restart_file = "#{@stub.app_root}/tmp/restart.txt"
-			now = Time.now
-			
-			File.open(controller, 'w') do |f|
-				f.write %q{
-					class TestController < ApplicationController
-						layout nil
-						def index
-							render :text => "foo"
-						end
-					end
-				}
-			end
-			File.open(restart_file, 'w').close
-			File.utime(now - 10, now - 10, restart_file)
-			get('/test').should == "foo"
-			
-			File.open(controller, 'w') do |f|
-				f.write %q{
-					class TestController < ApplicationController
-						layout nil
-						def index
-							render :text => "bar"
-						end
-					end
-				}
-			end
-
-			File.utime(now - 5, now - 5, restart_file)
-			get('/test').should == 'bar'
-		ensure
-			File.unlink(controller) rescue nil
-			File.unlink(restart_file) rescue nil
-		end
-	end
-	
-	it "does not make the web server crash if the app crashes" do
-		post('/welcome/terminate')
-		sleep(0.25) # Give the app the time to terminate itself.
-		get('/').should =~ /Welcome to MyCook/
-	end
-	
-	it "does not conflict with Phusion Passenger if there's a model named 'Passenger'" do
-		Dir.mkdir("#{@stub.app_root}/app/models") rescue nil
-		File.open("#{@stub.app_root}/app/models/passenger.rb", 'w') do |f|
-			f.write(%q{
-				class Passenger
-					def name
-						return "Gourry Gabriev"
-					end
-				end
-			})
-		end
-		begin
-			system "touch '#{@stub.app_root}/tmp/restart.txt'"
-			get('/welcome/passenger_name').should == 'Gourry Gabriev'
-		ensure
-			File.unlink("#{@stub.app_root}/app/models/passenger.rb") rescue nil
-		end
-	end
-	
-	it "sets the 'Status' header" do
-		response = get_response('/nonexistant')
-		response["Status"].should == "404 Not Found"
-	end
-	
-	if Process.uid == 0
-		it "runs as an unprivileged user" do
-			post('/welcome/touch')
-			begin
-				stat = File.stat("#{@stub.app_root}/public/touch.txt")
-				stat.uid.should_not == 0
-				stat.gid.should_not == 0
-			ensure
-				File.unlink("#{@stub.app_root}/public/touch.txt") rescue nil
-			end
-		end
-	end
-end
-
-shared_examples_for "HelloWorld Rack application" do
-	it "is possible to fetch static assets" do
-		get('/rack.jpg').should == public_file('rack.jpg')
-	end
-	
-	it "is possible to GET a regular Rack page" do
-		get('/').should =~ /hello/
-	end
-	
-	it "supports restarting via restart.txt" do
-		get('/').should =~ /hello/
-		File.write("#{@stub.app_root}/config.ru", %q{
-			app = lambda do |env|
-				[200, { "Content-Type" => "text/html" }, "changed"]
-			end
-			run app
-		})
-		File.new("#{@stub.app_root}/tmp/restart.txt", "w").close
-		File.utime(2, 2, "#{@stub.app_root}/tmp/restart.txt")
-		get('/').should == "changed"
-	end
-	
-	if Process.uid == 0
-		it "runs as an unprivileged user" do
-			File.prepend("#{@stub.app_root}/config.ru", %q{
-				File.new('foo.txt', 'w').close
-			})
-			File.new("#{@stub.app_root}/tmp/restart.txt", "w").close
-			File.utime(1, 1, "#{@stub.app_root}/tmp/restart.txt")
-			get('/')
-			stat = File.stat("#{@stub.app_root}/foo.txt")
-			stat.uid.should_not == 0
-			stat.gid.should_not == 0
-		end
-	end
-end
-
-shared_examples_for "HelloWorld WSGI application" do
-	after :each do
-		File.unlink("#{@stub.app_root}/passenger_wsgi.pyc") rescue nil
-	end
-	
-	it "is possible to fetch static assets" do
-		get('/wsgi-snake.jpg').should == public_file('wsgi-snake.jpg')
-	end
-	
-	it "is possible to GET a regular WSGI page" do
-		get('/').should =~ /Hello World/
-	end
-	
-	it "supports restarting via restart.txt" do
-		get('/').should =~ /Hello World/
-		
-		code = %q{
-			def application(env, start_response):
-				start_response('200 OK', [('Content-Type', 'text/html')])
-				return ["changed"]
-		}.gsub(/^\t\t\t/, '')
-		
-		File.write("#{@stub.app_root}/passenger_wsgi.py", code)
-		File.new("#{@stub.app_root}/tmp/restart.txt", "w").close
-		File.utime(2, 2, "#{@stub.app_root}/tmp/restart.txt")
-		get('/').should == "changed"
-	end
-	
-	if Process.uid == 0
-		it "runs as an unprivileged user" do
-			File.prepend("#{@stub.app_root}/passenger_wsgi.py",
-				"file('foo.txt', 'w').close()\n")
-			File.new("#{@stub.app_root}/tmp/restart.txt", "w").close
-			File.utime(1, 1, "#{@stub.app_root}/tmp/restart.txt")
-			get('/')
-			stat = File.stat("#{@stub.app_root}/foo.txt")
-			stat.uid.should_not == 0
-			stat.gid.should_not == 0
-		end
-	end
-end
-
 describe "mod_passenger running in Apache 2" do
 	include TestHelper
 	
@@ -269,6 +32,7 @@ describe "mod_passenger running in Apache 2" do
 	
 	describe ": MyCook(tm) beta running on root URI" do
 		before :all do
+			@web_server_supports_chunked_transfer_encoding = true
 			@server = "http://passenger.test:#{@apache2.port}"
 			@stub = setup_rails_stub('mycook')
 			@apache2 << "RailsMaxPoolSize 1"
@@ -333,6 +97,7 @@ describe "mod_passenger running in Apache 2" do
 	
 	describe ": MyCook(tm) beta running in a sub-URI" do
 		before :all do
+			@web_server_supports_chunked_transfer_encoding = true
 			@stub = setup_rails_stub('mycook')
 			FileUtils.rm_rf('tmp.webdir')
 			FileUtils.mkdir_p('tmp.webdir')
@@ -733,66 +498,9 @@ describe "mod_passenger running in Apache 2" do
 	
 	##### Helper methods #####
 	
-	def get(uri)
-		if !@apache2.running?
-			@apache2.start
-		end
-		return Net::HTTP.get(URI.parse("#{@server}#{uri}"))
-	end
-	
-	def get_response(uri)
-		if !@apache2.running?
-			@apache2.start
-		end
-		return Net::HTTP.get_response(URI.parse("#{@server}#{uri}"))
-	end
-	
-	def post(uri, params = {})
+	def start_web_server_if_necessary
 		if !@apache2.running?
 			@apache2.start
 		end
-		url = URI.parse("#{@server}#{uri}")
-		if params.values.any? { |x| x.respond_to?(:read) }
-			mp = Multipart::MultipartPost.new
-			query, headers = mp.prepare_query(params)
-			Net::HTTP.start(url.host, url.port) do |http|
-				return http.post(url.path, query, headers).body
-			end
-		else
-			return Net::HTTP.post_form(url, params).body
-		end
-	end
-	
-	def public_file(name)
-		return File.read("#{@stub.app_root}/public/#{name}")
-	end
-	
-	def check_hosts_configuration
-		begin
-			ok = Resolv.getaddress("passenger.test") == "127.0.0.1"
-		rescue Resolv::ResolvError, ArgumentError
-			# There's a bug in Ruby 1.8.6-p287's resolv.rb library, which causes
-			# an ArgumentError to be raised instead of ResolvError when resolving
-			# failed.
-			ok = false
-		end
-		if !ok
-			message = "To run the integration test, you must update " <<
-				"your hosts file.\n" <<
-				"Please add these to your /etc/hosts:\n\n" <<
-				"  127.0.0.1 passenger.test\n" <<
-				"  127.0.0.1 mycook.passenger.test\n" <<
-				"  127.0.0.1 zsfa.passenger.test\n" <<
-				"  127.0.0.1 norails.passenger.test\n"
-			if RUBY_PLATFORM =~ /darwin/
-				message << "\n\nThen run:\n\n" <<
-					"  lookupd -flushcache      (OS X Tiger)\n\n" <<
-					"-OR-\n\n" <<
-					"  dscacheutil -flushcache  (OS X Leopard)"
-			end
-			STDERR.puts "---------------------------"
-			STDERR.puts message
-			exit!
-		end
 	end
 end