passenger 3.0.21 → 3.9.1.beta

data/test/cxx/PoolOptionsTest.cpp

@@ -1,116 +0,0 @@
-#include "TestSupport.h"
-#include "PoolOptions.h"
-
-using namespace Passenger;
-using namespace std;
-
-namespace tut {
-	struct PoolOptionsTest {
-	};
-
-	DEFINE_TEST_GROUP(PoolOptionsTest);
-
-	// Test the PoolOptions constructors and toVector().
-	TEST_METHOD(1) {
-		PoolOptions options;
-		options.appRoot     = "/foo";
-		options.frameworkSpawnerTimeout = 123;
-		options.appSpawnerTimeout       = 456;
-		options.maxRequests = 789;
-		
-		vector<string> args;
-		args.push_back("abc");
-		args.push_back("def");
-		options.toVector(args);
-		
-		PoolOptions copy(args, 2);
-		ensure_equals(options.appRoot, copy.appRoot);
-		ensure_equals(options.rights, copy.rights);
-		ensure_equals(options.environment, copy.environment);
-		ensure_equals(options.spawnMethod, copy.spawnMethod);
-		ensure_equals(options.appType, copy.appType);
-		ensure_equals(options.frameworkSpawnerTimeout, copy.frameworkSpawnerTimeout);
-		ensure_equals(options.appSpawnerTimeout, copy.appSpawnerTimeout);
-		ensure_equals(options.maxRequests, copy.maxRequests);
-	}
-	
-	// Test empty environmentVariables serialization and deserialization.
-	TEST_METHOD(2) {
-		PoolOptions options;
-		vector<string> args;
-		options.toVector(args);
-		
-		PoolOptions options2(args);
-		ensure_equals(options2.environmentVariables->getItems()->size(), 0u);
-	}
-	
-	// Test single item environmentVariables serialization and deserialization.
-	TEST_METHOD(3) {
-		PoolOptions options;
-		SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator());
-		vector<string> args;
-		list->items->push_back("hello");
-		list->items->push_back("world !!");
-		options.environmentVariables = list;
-		options.toVector(args);
-		
-		PoolOptions options2(args);
-		const StringListPtr list2 = options2.environmentVariables->getItems();
-		ensure_equals(list2->size(), 2u);
-		ensure_equals(list2->at(0), "hello");
-		ensure_equals(list2->at(1), "world !!");
-	}
-	
-	// Test multiple items environmentVariables serialization and deserialization.
-	TEST_METHOD(4) {
-		PoolOptions options;
-		SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator());
-		vector<string> args;
-		list->items->push_back("hello");
-		list->items->push_back("world !!");
-		list->items->push_back("PATH");
-		list->items->push_back("/usr/local/bin");
-		options.environmentVariables = list;
-		options.toVector(args);
-		
-		PoolOptions options2(args);
-		const StringListPtr list2 = options2.environmentVariables->getItems();
-		ensure_equals(list2->size(), 4u);
-		ensure_equals(list2->at(0), "hello");
-		ensure_equals(list2->at(1), "world !!");
-		ensure_equals(list2->at(2), "PATH");
-		ensure_equals(list2->at(3), "/usr/local/bin");
-	}
-	
-	// Calling toVector() with storeEnvVars = false on a PoolOption object that
-	// has no environment variables works, and the resulting data can be unserialized.
-	TEST_METHOD(5) {
-		PoolOptions options;
-		vector<string> args;
-		options.appRoot = "hello";
-		options.toVector(args, false);
-		
-		PoolOptions options2(args);
-		ensure_equals(options2.appRoot, "hello");
-		ensure_equals(options2.environmentVariables, StringListCreatorPtr());
-	}
-	
-	// Calling toVector() with storeEnvVars = false on a PoolOption object that
-	// has no environment variables works, and the resulting data can be unserialized.
-	TEST_METHOD(6) {
-		PoolOptions options;
-		SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator());
-		vector<string> args;
-		list->items->push_back("hello");
-		list->items->push_back("world");
-		list->items->push_back("foo");
-		list->items->push_back("bar");
-		options.appRoot = "hello";
-		options.environmentVariables = list;
-		options.toVector(args, false);
-		
-		PoolOptions options2(args);
-		ensure_equals(options2.appRoot, "hello");
-		ensure_equals(options2.environmentVariables, StringListCreatorPtr());
-	}
-}

data/test/cxx/SpawnManagerTest.cpp

@@ -1,161 +0,0 @@
-#include "TestSupport.h"
-#include "SpawnManager.h"
-#include <sys/types.h>
-#include <signal.h>
-#include <cstring>
-#include <unistd.h>
-#include "valgrind.h"
-
-using namespace Passenger;
-
-namespace tut {
-	struct SpawnManagerTest {
-		ServerInstanceDirPtr serverInstanceDir;
-		ServerInstanceDir::GenerationPtr generation;
-		SpawnManagerPtr manager;
-		AccountsDatabasePtr accountsDatabase;
-		PoolOptions rackOptions;
-		
-		SpawnManagerTest() {
-			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
-			rackOptions.appRoot = "stub/rack";
-			rackOptions.appType = "rack";
-		}
-		
-		void initialize() {
-			manager = ptr(new SpawnManager("../helper-scripts/passenger-spawn-server", generation,
-				accountsDatabase));
-		}
-		
-		void sendTestRequest(SessionPtr &session, bool authenticate = true, const char *uri = "/foo/new") {
-			string headers;
-			#define ADD_HEADER(name, value) \
-				headers.append(name); \
-				headers.append(1, '\0'); \
-				headers.append(value); \
-				headers.append(1, '\0')
-			ADD_HEADER("HTTP_HOST", "www.test.com");
-			ADD_HEADER("QUERY_STRING", "");
-			ADD_HEADER("REQUEST_URI", uri);
-			ADD_HEADER("REQUEST_METHOD", "GET");
-			ADD_HEADER("REMOTE_ADDR", "localhost");
-			ADD_HEADER("SCRIPT_NAME", "");
-			ADD_HEADER("PATH_INFO", uri);
-			if (authenticate) {
-				ADD_HEADER("PASSENGER_CONNECT_PASSWORD", session->getConnectPassword());
-			}
-			session->sendHeaders(headers);
-		}
-	};
-
-	DEFINE_TEST_GROUP(SpawnManagerTest);
-
-	TEST_METHOD(1) {
-		// Spawning an application should return a valid Application object.
-		initialize();
-		ProcessPtr process = manager->spawn(rackOptions);
-		SessionPtr session = process->newSession();
-		sendTestRequest(session);
-		session->shutdownWriter();
-		string result = readAll(session->getStream());
-		ensure(result.find("hello <b>world</b>") != string::npos);
-	}
-	
-	TEST_METHOD(2) {
-		// If something goes wrong during spawning, the spawn manager
-		// should be restarted and another (successful) spawn should be attempted.
-		initialize();
-		pid_t old_pid = manager->getServerPid();
-		manager->killSpawnServer();
-		// Give the spawn server the time to properly terminate.
-		usleep(500000);
-		
-		ProcessPtr process = manager->spawn(rackOptions);
-		SessionPtr session = process->newSession();
-		sendTestRequest(session);
-		session->shutdownWriter();
-		string result = readAll(session->getStream());
-		ensure(result.find("hello <b>world</b>") != string::npos);
-		
-		// The following test will fail if we're inside Valgrind, but that's normal.
-		// Killing the spawn server doesn't work there.
-		if (!RUNNING_ON_VALGRIND) {
-			ensure("The spawn server was restarted", manager->getServerPid() != old_pid);
-		}
-	}
-	
-	class BuggySpawnManager: public SpawnManager {
-	protected:
-		virtual void spawnServerStarted() {
-			if (nextRestartShouldFail) {
-				nextRestartShouldFail = false;
-				killSpawnServer();
-				usleep(25000);
-			}
-		}
-		
-	public:
-		bool nextRestartShouldFail;
-		
-		BuggySpawnManager(const ServerInstanceDir::GenerationPtr &generation)
-			: SpawnManager("stub/spawn_server.rb", generation)
-		{
-			nextRestartShouldFail = false;
-		}
-	};
-	
-	TEST_METHOD(3) {
-		// If the spawn server dies after a restart, a SpawnException should be thrown.
-		
-		// This test fails in Valgrind, but that's normal.
-		// Killing the spawn server doesn't work there.
-		if (!RUNNING_ON_VALGRIND) {
-			BuggySpawnManager manager(generation);
-			manager.killSpawnServer();
-			// Give the spawn server the time to properly terminate.
-			usleep(250000);
-			
-			try {
-				manager.nextRestartShouldFail = true;
-				ProcessPtr process = manager.spawn(rackOptions);
-				fail("SpawnManager did not throw a SpawnException");
-			} catch (const SpawnException &e) {
-				// Success.
-			}
-		}
-	}
-	
-	TEST_METHOD(4) {
-		// The connect password is passed to the spawned application, which rejects
-		// sessions that aren't authenticated with the right password.
-		initialize();
-		ProcessPtr process = manager->spawn(rackOptions);
-		SessionPtr session = process->newSession();
-		sendTestRequest(session, false);
-		session->shutdownWriter();
-		string result = readAll(session->getStream());
-		ensure_equals(result, "");
-	}
-	
-	TEST_METHOD(5) {
-		// It automatically creates a unique account for the application,
-		// which is deleted when no longer needed.
-		accountsDatabase = ptr(new AccountsDatabase());
-		initialize();
-		
-		ProcessPtr process1 = manager->spawn(rackOptions);
-		vector<string> usernames1 = accountsDatabase->listUsernames();
-		ensure_equals(accountsDatabase->size(), 1u);
-		
-		ProcessPtr process2 = manager->spawn(rackOptions);
-		vector<string> usernames2 = accountsDatabase->listUsernames();
-		ensure_equals(accountsDatabase->size(), 2u);
-		
-		process1.reset();
-		ensure_equals(accountsDatabase->size(), 1u);
-		ensure_equals(accountsDatabase->get(usernames1[0]), AccountPtr());
-		
-		process2.reset();
-		ensure_equals(accountsDatabase->size(), 0u);
-	}
-}

data/test/ruby/abstract_server_collection_spec.rb

@@ -1,247 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'phusion_passenger/abstract_server'
-require 'phusion_passenger/abstract_server_collection'
-
-module PhusionPassenger
-
-describe AbstractServerCollection do
-	before :each do
-		@collection = AbstractServerCollection.new
-	end
-	
-	after :each do
-		@collection.cleanup
-	end
-	
-	specify "#lookup_or_add adds the server returned by its block" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') do
-				AbstractServer.new
-			end
-			@collection.should have_key('foo')
-		end
-	end
-	
-	specify "#lookup_or_add does not execute the block if the key exists" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') do
-				AbstractServer.new
-			end
-			@collection.lookup_or_add('foo') do
-				violated
-			end
-		end
-	end
-	
-	specify "#lookup_or_add returns the found server" do
-		@collection.synchronize do
-			server = AbstractServer.new
-			@collection.lookup_or_add('foo') { server }
-			result = @collection.lookup_or_add('foo') { AbstractServer.new }
-			result.should == server
-		end
-	end
-	
-	specify "#lookup_or_add returns the value of the block if server is not already in the collection" do
-		@collection.synchronize do
-			server = AbstractServer.new
-			result = @collection.lookup_or_add('foo') do
-				server
-			end
-			result.should == server
-		end
-	end
-	
-	specify "#delete deletes the server with the given key" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') do
-				AbstractServer.new
-			end
-			@collection.delete('foo')
-			@collection.should_not have_key('foo')
-		end
-	end
-	
-	specify "#delete stops the server if it's started" do
-		@collection.synchronize do
-			server = AbstractServer.new
-			@collection.lookup_or_add('foo') do
-				server.start
-				server
-			end
-			@collection.delete('foo')
-			server.should_not be_started
-		end
-	end
-	
-	specify "#clear deletes everything" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') do
-				AbstractServer.new
-			end
-			@collection.lookup_or_add('bar') do
-				AbstractServer.new
-			end
-			@collection.clear
-			@collection.should_not have_key('foo')
-			@collection.should_not have_key('bar')
-		end
-	end
-	
-	specify "#cleanup deletes everything" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') do
-				AbstractServer.new
-			end
-			@collection.lookup_or_add('bar') do
-				AbstractServer.new
-			end
-		end
-		@collection.cleanup
-		@collection.synchronize do
-			@collection.should_not have_key('foo')
-			@collection.should_not have_key('bar')
-		end
-	end
-	
-	specify "#cleanup stops all servers" do
-		servers = []
-		3.times do
-			server = AbstractServer.new
-			server.start
-			servers << server
-		end
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { servers[0] }
-			@collection.lookup_or_add('bar') { servers[1] }
-			@collection.lookup_or_add('baz') { servers[2] }
-		end
-		@collection.cleanup
-		servers.each do |server|
-			server.should_not be_started
-		end
-	end
-	
-	specify "idle servers are cleaned up periodically" do
-		foo = AbstractServer.new
-		foo.max_idle_time = 0.05
-		bar = AbstractServer.new
-		bar.max_idle_time = 2
-		
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { foo }
-			@collection.lookup_or_add('bar') { bar }
-		end
-		sleep 0.3
-		@collection.synchronize do
-			@collection.should_not have_key('foo')
-			@collection.should have_key('bar')
-		end
-	end
-	
-	specify "servers with max_idle_time of 0 are never cleaned up" do
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { AbstractServer.new }
-		end
-		original_cleaning_time = @collection.next_cleaning_time
-		@collection.check_idle_servers!
-		
-		# Wait until the cleaner thread has run.
-		while original_cleaning_time == @collection.next_cleaning_time
-			sleep 0.01
-		end
-		
-		@collection.synchronize do
-			@collection.should have_key('foo')
-		end
-	end
-	
-	specify "upon adding a new server to an empty collection, the next cleaning will " <<
-	        "be scheduled at that server's next cleaning time" do
-		server = AbstractServer.new
-		server.max_idle_time = 10
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { server }
-		end
-		@collection.next_cleaning_time.should == server.next_cleaning_time
-	end
-	
-	specify "upon adding a new server to a nonempty collection, and that server's next cleaning " <<
-	        "time is not the smallest of all servers' cleaning times, then the next cleaning schedule " <<
-	        "will not change" do
-		server1 = AbstractServer.new
-		server1.max_idle_time = 10
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { server1 }
-		end
-		
-		server2 = AbstractServer.new
-		server2.max_idle_time = 11
-		@collection.synchronize do
-			@collection.lookup_or_add('bar') { server2 }
-		end
-		
-		@collection.next_cleaning_time.should == server1.next_cleaning_time
-	end
-	
-	specify "upon deleting server from a nonempty collection, and the deleted server's next cleaning " <<
-	        "time IS the smallest of all servers' cleaning times, then the next cleaning schedule " <<
-	        "will be changed to the smallest cleaning time of all servers" do
-		server1 = AbstractServer.new
-		server1.max_idle_time = 10
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { server1 }
-		end
-		
-		server2 = AbstractServer.new
-		server2.max_idle_time = 11
-		@collection.synchronize do
-			@collection.lookup_or_add('bar') { server2 }
-		end
-		
-		@collection.synchronize do
-			@collection.delete('foo')
-		end
-		
-		@collection.next_cleaning_time.should == server2.next_cleaning_time
-	end
-	
-	specify "upon deleting server from a nonempty collection, and the deleted server's next cleaning " <<
-	        "time IS NOT the smallest of all servers' cleaning times, then the next cleaning schedule " <<
-	        "will not change" do
-		server1 = AbstractServer.new
-		server1.max_idle_time = 10
-		@collection.synchronize do
-			@collection.lookup_or_add('foo') { server1 }
-		end
-		
-		server2 = AbstractServer.new
-		server2.max_idle_time = 11
-		@collection.synchronize do
-			@collection.lookup_or_add('bar') { server2 }
-		end
-		
-		@collection.synchronize do
-			@collection.delete('bar')
-		end
-		
-		@collection.next_cleaning_time.should == server1.next_cleaning_time
-	end
-	
-	specify "bug check" do
-		block = lambda do
-			@collection.synchronize do
-				@collection.clear
-				@collection.lookup_or_add('foo') do
-					s = AbstractServer.new
-					s.max_idle_time = 0.05
-					s
-				end
-				@collection.lookup_or_add('bar') { AbstractServer.new }
-			end
-		end
-		block.should_not raise_error
-	end
-end
-
-end # module PhusionPassenger