passenger 3.0.21 → 3.9.1.beta

data/test/cxx/ScgiRequestParserTest.cpp

@@ -1,5 +1,5 @@
 #include "TestSupport.h"
-#include "ScgiRequestParser.h"
+#include "agents/HelperAgent/ScgiRequestParser.h"
 
 using namespace Passenger;
 using namespace std;
@@ -172,6 +172,19 @@ namespace tut {
 		ensure(parser.getHeader("hello") == "world");
 		ensure(parser.getHeader("foo") == "bar");
 	}
+
+	TEST_METHOD(13) {
+		// It makes an internal copy of the data.
+		char data[] = "20:hello\0world\0foo\0bar\0,";
+		for (unsigned int i = 0; i < sizeof(data) - 1; i++) {
+			ensure_equals(parser.feed(&data[i], 1), 1u);
+		}
+		memset(data, 0, sizeof(data));
+		ensure_equals(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. *****/
 	
@@ -206,28 +219,28 @@ namespace tut {
 	
 	TEST_METHOD(20) {
 		// Only a header name, without even a null terminator.
-		ensure_equals(parser.feed("5:hello,", 8), 7u);
+		ensure_equals(parser.feed("5:hello,", 8), (size_t) 8);
 		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.feed("6:hello\0,", 9), (size_t) 9);
 		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.feed("7:foo\0bar,", 10), (size_t) 10);
 		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.feed("10:foo\0bar\0a\0,", 14), (size_t) 14);
 		ensure_equals("Parser is in the error state.",
 			parser.getState(), ScgiRequestParser::ERROR);
 	}
@@ -242,7 +255,14 @@ namespace tut {
 	
 	TEST_METHOD(25) {
 		// An empty header name.
-		ensure_equals(parser.feed("5:\0bar\0,", 8), 7u);
+		ensure_equals(parser.feed("5:\0bar\0,", 8), (size_t) 8);
+		ensure_equals("Parser is in the error state.",
+			parser.getState(), ScgiRequestParser::ERROR);
+	}
+	
+	TEST_METHOD(26) {
+		// An empty header.
+		ensure_equals(parser.feed("0:,", 3), (size_t) 2);
 		ensure_equals("Parser is in the error state.",
 			parser.getState(), ScgiRequestParser::ERROR);
 	}
@@ -283,32 +303,32 @@ namespace tut {
 	
 	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.feed("5:hell", 6), (size_t) 6);
+		ensure_equals(parser.feed("o,", 2), (size_t) 2);
 		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.feed("6:hello", 7), (size_t) 7);
+		ensure_equals(parser.feed("\0,", 2), (size_t) 2);
 		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.feed("7:foo\0ba", 8), (size_t) 8);
+		ensure_equals(parser.feed("r,", 2), (size_t) 2);
 		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.feed("10:foo\0bar\0a", 12), (size_t) 12);
+		ensure_equals(parser.feed("\0,", 2), (size_t) 2);
 		ensure_equals("Parser is in the error state.",
 			parser.getState(), ScgiRequestParser::ERROR);
 	}
@@ -336,8 +356,8 @@ namespace tut {
 	
 	TEST_METHOD(37) {
 		// An empty header name.
-		ensure_equals(parser.feed("5:\0", 3), 3u);
-		ensure_equals(parser.feed("bar\0,", 5), 4u);
+		ensure_equals(parser.feed("5:\0", 3), (size_t) 3);
+		ensure_equals(parser.feed("bar\0,", 5), (size_t) 5);
 		ensure_equals("Parser is in the error state.",
 			parser.getState(), ScgiRequestParser::ERROR);
 	}

data/test/cxx/ServerInstanceDirTest.cpp

@@ -17,7 +17,7 @@ namespace tut {
 		
 		void createGenerationDir(const string &instanceDir, unsigned int number) {
 			string command = "mkdir " + instanceDir + "/generation-" + toString(number);
-			system(command.c_str());
+			runShellCommand(command.c_str());
 		}
 	};
 	

data/test/cxx/StringMapTest.cpp

@@ -1,6 +1,7 @@
 #include "TestSupport.h"
 #include "Utils/StringMap.h"
 #include <string>
+#include <map>
 
 using namespace Passenger;
 using namespace std;
@@ -67,4 +68,64 @@ namespace tut {
 		ensure_equals(m.get("foo"), "bar");
 		ensure(!m.remove("hello"));
 	}
+	
+	TEST_METHOD(6) {
+		// Test iterators.
+		StringMap<int> m;
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 3);
+		m.set("d", 4);
+		
+		map<string, int> m2, m3;
+		
+		StringMap<int>::iterator it, end = m.end();
+		for (it = m.begin(); it != end; it++) {
+			pair<StaticString, int> p = *it;
+			m2[it->first] = it->second;
+			m3[p.first] = p.second;
+		}
+		
+		ensure_equals(m2.size(), 4u);
+		ensure_equals(m2["a"], 1);
+		ensure_equals(m2["b"], 2);
+		ensure_equals(m2["c"], 3);
+		ensure_equals(m2["d"], 4);
+		
+		ensure_equals(m3.size(), 4u);
+		ensure_equals(m3["a"], 1);
+		ensure_equals(m3["b"], 2);
+		ensure_equals(m3["c"], 3);
+		ensure_equals(m3["d"], 4);
+	}
+	
+	TEST_METHOD(7) {
+		// Test const_iterators.
+		StringMap<int> m;
+		m.set("a", 1);
+		m.set("b", 2);
+		m.set("c", 3);
+		m.set("d", 4);
+		
+		map<string, int> m2, m3;
+		
+		StringMap<int>::const_iterator it, end = m.end();
+		for (it = m.begin(); it != end; it++) {
+			pair<const StaticString, const int> p = *it;
+			m2[it->first] = it->second;
+			m3[p.first] = p.second;
+		}
+		
+		ensure_equals(m2.size(), 4u);
+		ensure_equals(m2["a"], 1);
+		ensure_equals(m2["b"], 2);
+		ensure_equals(m2["c"], 3);
+		ensure_equals(m2["d"], 4);
+		
+		ensure_equals(m3.size(), 4u);
+		ensure_equals(m3["a"], 1);
+		ensure_equals(m3["b"], 2);
+		ensure_equals(m3["c"], 3);
+		ensure_equals(m3["d"], 4);
+	}
 }

data/test/cxx/TemplateTest.cpp

@@ -0,0 +1,118 @@
+#include <TestSupport.h>
+#include <Utils/Template.h>
+#include <cstdarg>
+
+using namespace Passenger;
+
+namespace tut {
+	struct TemplateTest {
+		string apply(const StaticString &templateContent, ...) {
+			va_list ap;
+			const char *arg;
+			StringMap<StaticString> params;
+
+			va_start(ap, templateContent);
+			while ((arg = va_arg(ap, const char *)) != NULL) {
+				params.set(arg, va_arg(ap, const char *));
+			}
+			string result = Template::apply(templateContent, params);
+			va_end(ap);
+			return result;
+		}
+	};
+	
+	DEFINE_TEST_GROUP(TemplateTest);
+	
+	TEST_METHOD(1) {
+		// Test 1 substitution.
+		string result = apply("hello {{name}}",
+			"name", "world",
+			NULL);
+		ensure_equals(result, "hello world");
+	}
+
+	TEST_METHOD(2) {
+		// Test multiple substitutions.
+		string result = apply("hello {{name}} and {{name2}}",
+			"name", "joe",
+			"name2", "jane",
+			NULL);
+		ensure_equals(result, "hello joe and jane");
+	}
+
+	TEST_METHOD(3) {
+		// Test unspecified substitutions.
+		string result = apply("hello {{name}} and {{name2}}!",
+			"name", "joe",
+			NULL);
+		ensure_equals(result, "hello joe and !");
+	}
+
+	TEST_METHOD(4) {
+		// Test default values.
+		string result = apply("hello {{name|default=joe}} and {{name2|default=jane}}",
+			NULL);
+		ensure_equals(result, "hello joe and jane");
+	}
+
+	TEST_METHOD(5) {
+		// Substitutions are HTML-escaped by default.
+		string result = apply("hello {{name}}",
+			"name", "<joe>",
+			NULL);
+		ensure_equals(result, "hello &lt;joe&gt;");
+		result = apply("hello {{name|default=<joe>}}",
+			NULL);
+		ensure_equals(result, "hello &lt;joe&gt;");
+	}
+
+	TEST_METHOD(6) {
+		// HTML escaping can be disabled with the 'raw' option.
+		string result = apply("hello {{name|raw}}",
+			"name", "<joe>",
+			NULL);
+		ensure_equals(result, "hello <joe>");
+	}
+
+	TEST_METHOD(7) {
+		// Test combining default values and the 'raw' option.
+		string result = apply("hello {{name|raw,default=<joe>}}",
+			NULL);
+		ensure_equals(result, "hello <joe>");
+	}
+
+	TEST_METHOD(8) {
+		// Test 'if' statements.
+		string result = apply("hello. {{if morning}}good morning. {{/if}}{{if evening}}good evening. {{/if}}",
+			"morning", "true",
+			NULL);
+		ensure_equals(result, "hello. good morning. ");
+	}
+
+	TEST_METHOD(9) {
+		// An 'if' condition is considered true when it is neither the empty string nor "false".
+		string result = apply("hello. {{if morning}}good morning. {{/if}}"
+			"{{if afternoon}}good afternoon. {{/if}"
+			"{{if evening}}good evening. {{/if}}",
+			"morning", "of course",
+			"afternoon", "false",
+			NULL);
+		ensure_equals(result, "hello. good morning. ");
+	}
+
+	TEST_METHOD(10) {
+		// Test nesting substitutions within 'if's.
+		string result = apply("hello. {{if name}}good morning {{name}}.{{/if}}",
+			"name", "joe",
+			NULL);
+		ensure_equals(result, "hello. good morning joe.");
+	}
+
+	TEST_METHOD(11) {
+		// Test auto-breaking on certain characters.
+		string result = apply("{{content}}",
+			"content", "Hello, world: a=b;c=d",
+			NULL);
+		ensure_equals(result, "Hello,<wbr> world:<wbr> a=<wbr>b;<wbr>c=<wbr>d");
+	}
+}

data/test/cxx/TestSupport.cpp

@@ -1,12 +1,21 @@
+#include "TestSupport.h"
 #include <dirent.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <pwd.h>
 #include <grp.h>
-#include "TestSupport.h"
+#include <cassert>
+#include <BackgroundEventLoop.cpp>
+#include <Utils/IOUtils.h>
+#include <Utils/ScopeGuard.h>
+#include <Utils/json.h>
 
 namespace TestSupport {
 
+ResourceLocator *resourceLocator = NULL;
+Json::Value testConfig;
+
+
 void createServerInstanceDirAndGeneration(ServerInstanceDirPtr &serverInstanceDir,
                                           ServerInstanceDir::GenerationPtr &generation)
 {
@@ -16,45 +25,6 @@ void createServerInstanceDirAndGeneration(ServerInstanceDirPtr &serverInstanceDi
 		geteuid(), getegid());
 }
 
-string
-readAll(const string &filename) {
-	FILE *f = fopen(filename.c_str(), "rb");
-	if (f != NULL) {
-		try {
-			string result = readAll(fileno(f));
-			fclose(f);
-			return result;
-		} catch (...) {
-			fclose(f);
-			throw;
-		}
-	} else {
-		int e = errno;
-		throw FileSystemException("Cannot open '" + filename + "' for reading",
-			e, filename);
-	}
-}
-
-string
-readAll(int fd) {
-	string result;
-	char buf[1024 * 32];
-	ssize_t ret;
-	while (true) {
-		do {
-			ret = read(fd, buf, sizeof(buf));
-		} while (ret == -1 && errno == EINTR);
-		if (ret == 0) {
-			break;
-		} else if (ret == -1) {
-			throw SystemException("Cannot read from socket", errno);
-		} else {
-			result.append(buf, ret);
-		}
-	}
-	return result;
-}
-
 void
 writeUntilFull(int fd) {
 	int flags, ret;
@@ -101,41 +71,26 @@ writeUntilFull(int fd) {
 	fcntl(fd, F_SETFL, flags);
 }
 
-string
-replaceString(const string &str, const string &toFind, const string &replaceWith) {
-	string::size_type pos = str.find(toFind);
-	if (pos == string::npos) {
-		return str;
-	} else {
-		string result(str);
-		return result.replace(pos, toFind.size(), replaceWith);
-	}
-}
-
 void
 replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith) {
-	FILE *f = fopen(filename, "r");
-	if (f == NULL) {
-		int e = errno;
-		string message = "Cannot open file '";
-		message.append(filename);
-		message.append("' for reading");
-		throw FileSystemException(message, e, filename);
-	}
-	string content(readAll(fileno(f)));
-	fclose(f);
-	
-	f = fopen(filename, "w");
+	string content = readAll(filename);
+	FILE *f = fopen(filename, "w");
 	if (f == NULL) {
 		int e = errno;
 		string message = "Cannot open file '";
 		message.append(filename);
 		message.append("' for writing");
 		throw FileSystemException(message, e, filename);
+	} else {
+		StdioGuard guard(f);
+		content = replaceString(content, toFind, replaceWith);
+		fwrite(content.data(), 1, content.size(), f);
 	}
-	content = replaceString(content, toFind, replaceWith);
-	fwrite(content.data(), 1, content.size(), f);
-	fclose(f);
+}
+
+bool
+containsSubstring(const StaticString &str, const StaticString &substr) {
+	return str.find(substr) != string::npos;
 }
 
 void
@@ -147,9 +102,10 @@ writeFile(const string &filename, const string &contents) {
 		message.append(filename);
 		message.append("' for writing");
 		throw FileSystemException(message, e, filename);
+	} else {
+		StdioGuard guard(f);
+		fwrite(contents.data(), 1, contents.size(), f);
 	}
-	fwrite(contents.data(), 1, contents.size(), f);
-	fclose(f);
 }
 
 void
@@ -210,4 +166,5 @@ getPrimaryGroupName(const string &username) {
 	return group->gr_name;
 }
 
+
 } // namespace TestSupport