passenger-jmazzi 2.2.9

data/test/SpawnManagerTest.cpp

@@ -0,0 +1,64 @@
+#include "tut.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 {
+		SpawnManager manager;
+		
+		SpawnManagerTest(): manager("stub/spawn_server.rb") {}
+	};
+
+	DEFINE_TEST_GROUP(SpawnManagerTest);
+
+	TEST_METHOD(1) {
+		// Spawning an application should return a valid Application object.
+		ApplicationPtr app(manager.spawn(PoolOptions(".")));
+		ensure_equals("The Application object's PID is the same as the one specified by the stub",
+			app->getPid(), 1234);
+	}
+	
+	TEST_METHOD(2) {
+		// If something goes wrong during spawning, the spawn manager
+		// should be restarted and another (successful) spawn should be attempted.
+		pid_t old_pid = manager.getServerPid();
+		kill(manager.getServerPid(), SIGTERM);
+		// Give the spawn server the time to properly terminate.
+		usleep(500000);
+		
+		ApplicationPtr app(manager.spawn(PoolOptions(".")));
+		ensure_equals("The Application object's PID is the same as the one specified by the stub",
+			app->getPid(), 1234);
+		
+		// The following test will fail if we're inside Valgrind, but that's normal.
+		// Killing the spawn server doesn't work.
+		if (!RUNNING_ON_VALGRIND) {
+			ensure("The spawn server was restarted", manager.getServerPid() != old_pid);
+		}
+	}
+	
+	TEST_METHOD(3) {
+		// This test fails in Valgrind, but that's normal.
+		// Killing the spawn server doesn't work.
+		if (!RUNNING_ON_VALGRIND) {
+			// If the spawn server dies after a restart, a SpawnException should be thrown.
+			kill(manager.getServerPid(), SIGTERM);
+			// Give the spawn server the time to properly terminate.
+			usleep(500000);
+			
+			try {
+				manager.nextRestartShouldFail = true;
+				ApplicationPtr app(manager.spawn(PoolOptions(".")));
+				fail("SpawnManager did not throw a SpawnException");
+			} catch (const SpawnException &e) {
+				// Success.
+			}
+		}
+	}
+}

data/test/StandardApplicationPoolTest.cpp

@@ -0,0 +1,27 @@
+#include "tut.h"
+#include "support/Support.h"
+#include "StandardApplicationPool.h"
+#include "Utils.h"
+
+using namespace Passenger;
+using namespace Test;
+
+namespace tut {
+	struct StandardApplicationPoolTest {
+		ApplicationPoolPtr pool, pool2;
+		
+		StandardApplicationPoolTest() {
+			pool = ptr(new StandardApplicationPool("../bin/passenger-spawn-server"));
+			pool2 = pool;
+		}
+		
+		ApplicationPoolPtr newPoolConnection() {
+			return pool;
+		}
+	};
+
+	DEFINE_TEST_GROUP(StandardApplicationPoolTest);
+
+	#define USE_TEMPLATE
+	#include "ApplicationPoolTest.cpp"
+}

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/SystemTimeTest.cpp

@@ -0,0 +1,37 @@
+#include "tut.h"
+#include "SystemTime.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct SystemTimeTest {
+		~SystemTimeTest() {
+			SystemTime::release();
+		}
+	};
+	
+	DEFINE_TEST_GROUP(SystemTimeTest);
+	
+	TEST_METHOD(1) {
+		time_t begin = SystemTime::get();
+		
+		SystemTime::force(1);
+		ensure_equals(SystemTime::get(), (time_t) 1);
+		SystemTime::release();
+		
+		time_t now = SystemTime::get();
+		ensure(now >= begin && now <= begin + 2);
+	}
+	
+	TEST_METHOD(2) {
+		time_t begin = SystemTime::get();
+		
+		SystemTime::force(1);
+		ensure_equals(SystemTime::get(), (time_t) 1);
+		SystemTime::release();
+		
+		time_t now = SystemTime::get();
+		ensure(now >= begin && now <= begin + 2);
+	}
+}

data/test/UtilsTest.cpp

@@ -0,0 +1,257 @@
+#include "tut.h"
+#include "Utils.h"
+#include "support/Support.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+
+using namespace Passenger;
+using namespace std;
+using namespace Test;
+
+namespace tut {
+	struct UtilsTest {
+		vector<string> output;
+		string oldPath;
+		string oldPassengerTempDir;
+		
+		UtilsTest() {
+			oldPath = getenv("PATH");
+			oldPassengerTempDir = getPassengerTempDir();
+			setPassengerTempDir("");
+			unsetenv("TMPDIR");
+		}
+		
+		~UtilsTest() {
+			setenv("PATH", oldPath.c_str(), 1);
+			unsetenv("TMPDIR");
+			setPassengerTempDir(oldPassengerTempDir);
+		}
+	};
+	
+	static vector<string>
+	listDir(const char *path) {
+		vector<string> result;
+		DIR *d = opendir(path);
+		struct dirent *ent;
+		
+		while ((ent = readdir(d)) != NULL) {
+			if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
+				continue;
+			}
+			result.push_back(ent->d_name);
+		}
+		return result;
+	}
+
+	DEFINE_TEST_GROUP(UtilsTest);
+
+	/***** Test split() *****/
+
+	TEST_METHOD(1) {
+		split("", ':', output);
+		ensure_equals(output.size(), 1u);
+		ensure_equals(output[0], "");
+	}
+	
+	TEST_METHOD(2) {
+		split("hello world", ':', output);
+		ensure_equals(output.size(), 1u);
+		ensure_equals(output[0], "hello world");
+	}
+	
+	TEST_METHOD(3) {
+		split("hello world:foo bar", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "hello world");
+		ensure_equals(output[1], "foo bar");
+	}
+	
+	TEST_METHOD(4) {
+		split("hello world:", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "hello world");
+		ensure_equals(output[1], "");
+	}
+	
+	TEST_METHOD(5) {
+		split(":hello world", ':', output);
+		ensure_equals(output.size(), 2u);
+		ensure_equals(output[0], "");
+		ensure_equals(output[1], "hello world");
+	}
+	
+	TEST_METHOD(6) {
+		split("abc:def::ghi", ':', output);
+		ensure_equals(output.size(), 4u);
+		ensure_equals(output[0], "abc");
+		ensure_equals(output[1], "def");
+		ensure_equals(output[2], "");
+		ensure_equals(output[3], "ghi");
+	}
+	
+	TEST_METHOD(7) {
+		split("abc:::def", ':', output);
+		ensure_equals(output.size(), 4u);
+		ensure_equals(output[0], "abc");
+		ensure_equals(output[1], "");
+		ensure_equals(output[2], "");
+		ensure_equals(output[3], "def");
+	}
+	
+	
+	/**** Test findSpawnServer() ****/
+	
+	TEST_METHOD(8) {
+		// If $PATH is empty, it should not find anything.
+		setenv("PATH", "", 1);
+		ensure_equals(findSpawnServer(), "");
+	}
+	
+	TEST_METHOD(9) {
+		// It should ignore relative paths.
+		setenv("PATH", "../bin", 1);
+		ensure_equals(findSpawnServer(), "");
+	}
+	
+	TEST_METHOD(10) {
+		// It should find in $PATH.
+		char cwd[PATH_MAX];
+		string binpath(getcwd(cwd, sizeof(cwd)));
+		binpath.append("/../bin");
+		setenv("PATH", binpath.c_str(), 1);
+		ensure("Spawn server is found.", !findSpawnServer().empty());
+	}
+	
+	
+	/***** Test getSystemTempDir() *****/
+	
+	TEST_METHOD(11) {
+		// It returns "/tmp" if the TMPDIR environment is NULL.
+		ensure_equals(string(getSystemTempDir()), "/tmp");
+	}
+	
+	TEST_METHOD(12) {
+		// It returns "/tmp" if the TMPDIR environment is an empty string.
+		setenv("TMPDIR", "", 1);
+		ensure_equals(string(getSystemTempDir()), "/tmp");
+	}
+	
+	TEST_METHOD(13) {
+		// It returns the value of the TMPDIR environment if it is not NULL and not empty.
+		setenv("TMPDIR", "/foo", 1);
+		ensure_equals(string(getSystemTempDir()), "/foo");
+	}
+	
+	
+	/***** Test getPassengerTempDir() *****/
+	
+	TEST_METHOD(15) {
+		// It returns "(tempdir)/passenger.(pid)"
+		char dir[128];
+		
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%lu", (unsigned long) getpid());
+		ensure_equals(getPassengerTempDir(), dir);
+	}
+	
+	TEST_METHOD(16) {
+		// It returns the cached value if it's not the empty string.
+		setPassengerTempDir("/foo");
+		ensure_equals(getPassengerTempDir(), "/foo");
+		
+		setPassengerTempDir("/bar");
+		ensure_equals(getPassengerTempDir(), "/bar");
+		
+		char dir[128];
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%lu", (unsigned long) getpid());
+		setPassengerTempDir("");
+		ensure_equals(getPassengerTempDir(), dir);
+	}
+	
+	TEST_METHOD(17) {
+		// It does not use query the cached value if bypassCache is true.
+		char dir[128];
+		
+		setPassengerTempDir("/foo");
+		snprintf(dir, sizeof(dir), "/tmp/passenger.%lu", (unsigned long) getpid());
+		ensure_equals(getPassengerTempDir(true), dir);
+	}
+	
+	TEST_METHOD(18) {
+		// It uses the systemTempDir argument if it's not the empty string.
+		char dir[128];
+		
+		snprintf(dir, sizeof(dir), "/foo/passenger.%lu", (unsigned long) getpid());
+		ensure_equals(getPassengerTempDir(false, "/foo"), dir);
+	}
+	
+	
+	/***** Test BufferedUpload *****/
+	
+	TEST_METHOD(20) {
+		// The resulting file handle is readable and writable.
+		TempDir td("utils_test.tmp");
+		BufferedUpload t("utils_test.tmp");
+		char line[30];
+		
+		fprintf(t.handle, "hello world!");
+		fflush(t.handle);
+		fseek(t.handle, 0, SEEK_SET);
+		memset(line, 0, sizeof(line));
+		fgets(line, sizeof(line), t.handle);
+		ensure_equals(string(line), "hello world!");
+	}
+	
+	TEST_METHOD(21) {
+		// It immediately unlinks the temp file.
+		TempDir td("utils_test.tmp");
+		BufferedUpload t("utils_test.tmp");
+		ensure_equals(listDir("utils_test.tmp").size(), 0u);
+	}
+	
+	/***** Test escapeForXml() *****/
+	
+	TEST_METHOD(25) {
+		ensure_equals(escapeForXml(""), "");
+		ensure_equals(escapeForXml("hello world"), "hello world");
+		ensure_equals(escapeForXml("./hello_world/foo.txt"), "./hello_world/foo.txt");
+		ensure_equals(escapeForXml("hello<world"), "hello&#60;world");
+		ensure_equals(escapeForXml("hello\xFFworld"), "hello&#255;world");
+		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

@@ -0,0 +1,30 @@
+### This file contains system-specific configuration options that the test suite needs.
+### Please customize it for your system.
+
+# These are the user names of two normal, non-administrator users.
+# Preferably, these are user accounts that are normally not used.
+#
+# NOTE: these users MUST be able to access this 'test' directory,
+# otherwise the tests will fail.
+normal_user_1: games
+normal_user_2: daemon
+
+# The username of a user that has less privileges than a normal user.
+#
+# NOTES:
+# - this user MUST be able to access this 'test' directory, otherwise
+#   the tests will fail.
+# - this user MUST NOT have a negative UID value. So on OS X, this may
+#   not be the 'nobody' user.
+lowest_user: nobody
+
+# A nonexistant username.
+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