001: // Copyright (C) 2003,2004,2005 by Object Mentor, Inc. All rights reserved.
002: // Released under the terms of the GNU General Public License version 2 or later.
003: package fitnesse.responders.run;
004:
005: import fitnesse.http.*;
006: import fitnesse.wiki.*;
007: import fitnesse.*;
008: import fitnesse.authentication.*;
009: import fitnesse.responders.SecureResponder;
010: import fitnesse.testutil.*;
011: import java.util.regex.*;
012:
013: public class TestResponderTest extends RegexTest {
014: private WikiPage root;
015: private MockRequest request;
016: private TestResponder responder;
017: private FitNesseContext context;
018: private int port = 9123;
019: private Response response;
020: private MockResponseSender sender;
021: private WikiPage testPage;
022: private String results;
023: private FitSocketReceiver receiver;
024: private WikiPage errorLogsParentPage;
025: private PageCrawler crawler;
026: private String simpleRunPageName;
027:
028: public void setUp() throws Exception {
029: root = InMemoryPage.makeRoot("RooT");
030: crawler = root.getPageCrawler();
031: errorLogsParentPage = crawler.addPage(root, PathParser
032: .parse("ErrorLogs"));
033: request = new MockRequest();
034: responder = new TestResponder();
035: context = new FitNesseContext(root);
036: context.port = port;
037:
038: receiver = new FitSocketReceiver(port, context.socketDealer);
039: receiver.receiveSocket();
040: }
041:
042: public void tearDown() throws Exception {
043: receiver.close();
044: }
045:
046: public void testSimpleRun() throws Exception {
047: doSimpleRun(passFixtureTable());
048:
049: assertSubString(testPage.getName(), results);
050: assertSubString("Test Results", results);
051: assertSubString("class", results);
052: assertNotSubString("ClassNotFoundException", results);
053: }
054:
055: private void doSimpleRun(String fixtureTable) throws Exception {
056: simpleRunPageName = "TestPage";
057: testPage = crawler.addPage(root, PathParser
058: .parse(simpleRunPageName), classpathWidgets()
059: + fixtureTable);
060: request.setResource(testPage.getName());
061:
062: response = responder.makeResponse(context, request);
063: sender = new MockResponseSender(response);
064:
065: results = sender.sentData();
066: }
067:
068: public void testEmptyTestPage() throws Exception {
069: PageData data = root.getData();
070: data.setContent(classpathWidgets());
071: root.commit(data);
072: testPage = crawler.addPage(root, PathParser
073: .parse("EmptyTestPage"));
074: request.setResource(testPage.getName());
075:
076: response = responder.makeResponse(context, request);
077: sender = new MockResponseSender(response);
078: sender.sentData();
079:
080: WikiPagePath errorLogPath = PathParser
081: .parse("ErrorLogs.EmptyTestPage");
082: WikiPage errorLogPage = crawler.getPage(root, errorLogPath);
083: String errorLogContent = errorLogPage.getData().getContent();
084: assertNotSubString("Exception", errorLogContent);
085: }
086:
087: public void testFitSocketGetsClosed() throws Exception {
088: doSimpleRun(passFixtureTable());
089: assertTrue(receiver.socket.isClosed());
090: }
091:
092: public void testStandardOutput() throws Exception {
093: String content = classpathWidgets()
094: + outputWritingTable("output1")
095: + outputWritingTable("output2")
096: + outputWritingTable("output3");
097:
098: String errorLogContent = doRunAndGetErrorLog(content);
099:
100: assertHasRegexp("output1", errorLogContent);
101: assertHasRegexp("output2", errorLogContent);
102: assertHasRegexp("output3", errorLogContent);
103: }
104:
105: public void testErrorOutput() throws Exception {
106: String content = classpathWidgets()
107: + errorWritingTable("error1")
108: + errorWritingTable("error2")
109: + errorWritingTable("error3");
110:
111: String errorLogContent = doRunAndGetErrorLog(content);
112:
113: assertHasRegexp("error1", errorLogContent);
114: assertHasRegexp("error2", errorLogContent);
115: assertHasRegexp("error3", errorLogContent);
116: }
117:
118: private String doRunAndGetErrorLog(String content) throws Exception {
119: WikiPage testPage = crawler.addPage(root, PathParser
120: .parse("TestPage"), content);
121: request.setResource(testPage.getName());
122:
123: Response response = responder.makeResponse(context, request);
124: MockResponseSender sender = new MockResponseSender(response);
125: String results = sender.sentData();
126:
127: assertHasRegexp("ErrorLog", results);
128:
129: WikiPage errorLog = errorLogsParentPage.getChildPage(testPage
130: .getName());
131: return errorLog.getData().getContent();
132: }
133:
134: public void testHasExitValueHeader() throws Exception {
135: WikiPage testPage = crawler.addPage(root, PathParser
136: .parse("TestPage"), classpathWidgets()
137: + passFixtureTable());
138: request.setResource(testPage.getName());
139:
140: Response response = responder.makeResponse(context, request);
141: MockResponseSender sender = new MockResponseSender(response);
142: String results = sender.sentData();
143:
144: assertSubString("Exit-Code: 0", results);
145: }
146:
147: public void testFixtureThatCrashes() throws Exception {
148: WikiPage testPage = crawler.addPage(root, PathParser
149: .parse("TestPage"), classpathWidgets()
150: + crashFixtureTable());
151: request.setResource(testPage.getName());
152:
153: Response response = responder.makeResponse(context, request);
154: MockResponseSender sender = new MockResponseSender(response);
155:
156: String results = sender.sentData();
157: assertSubString("ErrorLog", results);
158: }
159:
160: public void testResultsIncludeActions() throws Exception {
161: doSimpleRun(passFixtureTable());
162: assertSubString("<div class=\"actions\">", results);
163: }
164:
165: public void testResultsHaveHeaderAndFooter() throws Exception {
166: crawler.addPage(root, PathParser.parse("PageHeader"), "HEADER");
167: crawler.addPage(root, PathParser.parse("PageFooter"), "FOOTER");
168: doSimpleRun(passFixtureTable());
169: assertSubString("HEADER", results);
170: assertSubString("FOOTER", results);
171: }
172:
173: public void testExecutionStatusAppears() throws Exception {
174: doSimpleRun(passFixtureTable());
175: assertHasRegexp("<div id=\"execution-status\">.*?</div>",
176: results);
177: }
178:
179: private String getExecutionStatusMessage() throws Exception {
180: Pattern pattern = Pattern
181: .compile(
182: "<div id=\"execution-status\">.*?<a href=\"ErrorLogs\\.[^\"]*\">([^<>]*?)</a>.*?</div>",
183: Pattern.DOTALL);
184: Matcher matcher = pattern.matcher(results);
185: matcher.find();
186: return matcher.group(1);
187: }
188:
189: private String getExecutionStatusIconFilename() {
190: Pattern pattern = Pattern
191: .compile(
192: "<div id=\"execution-status\">.*?<img.*?src=\"(?:[^/]*/)*([^/]*\\.gif)\".*?/>.*?</div>",
193: Pattern.DOTALL);
194: Matcher matcher = pattern.matcher(results);
195: matcher.find();
196: return matcher.group(1);
197: }
198:
199: public void testExecutionStatusOk() throws Exception {
200: doSimpleRun(passFixtureTable());
201: assertEquals("Tests Executed OK", getExecutionStatusMessage());
202: assertEquals("ok.gif", getExecutionStatusIconFilename());
203: }
204:
205: public void testExecutionStatusOutputCaptured() throws Exception {
206: doSimpleRun(outputWritingTable("blah"));
207: assertEquals("Output Captured", getExecutionStatusMessage());
208: assertEquals("output.gif", getExecutionStatusIconFilename());
209: }
210:
211: public void testExecutionStatusError() throws Exception {
212: doSimpleRun(crashFixtureTable());
213: assertEquals("Errors Occurred", getExecutionStatusMessage());
214: assertEquals("error.gif", getExecutionStatusIconFilename());
215: }
216:
217: public void testExecutionStatusErrorHasPriority() throws Exception {
218: doSimpleRun(errorWritingTable("blah") + crashFixtureTable());
219: assertEquals("Errors Occurred", getExecutionStatusMessage());
220: }
221:
222: public void testTestSummaryAppears() throws Exception {
223: doSimpleRun(passFixtureTable());
224: assertHasRegexp(divWithIdAndContent("test-summary", ".*?"),
225: results);
226: }
227:
228: public void testTestSummaryInformationAppears() throws Exception {
229: doSimpleRun(passFixtureTable());
230: assertHasRegexp(
231: "<script>.*?document\\.getElementById\\(\"test-summary\"\\)\\.innerHTML = \".*?Assertions:.*?\";.*?</script>",
232: results);
233: assertHasRegexp(
234: "<script>.*?document\\.getElementById\\(\"test-summary\"\\)\\.className = \".*?\";.*?</script>",
235: results);
236: }
237:
238: public void testTestSummaryHasRightClass() throws Exception {
239: doSimpleRun(passFixtureTable());
240: assertHasRegexp(
241: "<script>.*?document\\.getElementById\\(\"test-summary\"\\)\\.className = \"pass\";.*?</script>",
242: results);
243: }
244:
245: public void testAuthentication_RequiresTestPermission()
246: throws Exception {
247: assertTrue(responder instanceof SecureResponder);
248: SecureOperation operation = ((SecureResponder) responder)
249: .getSecureOperation();
250: assertEquals(SecureTestOperation.class, operation.getClass());
251: }
252:
253: public void testNotifyListeners() throws Exception {
254: MockTestEventListener listener1 = new MockTestEventListener();
255: MockTestEventListener listener2 = new MockTestEventListener();
256:
257: TestResponder.registerListener(listener1);
258: TestResponder.registerListener(listener2);
259:
260: doSimpleRun(passFixtureTable());
261:
262: assertEquals(true, listener1.gotPreTestNotification);
263: assertEquals(true, listener2.gotPreTestNotification);
264: }
265:
266: public void testSuiteSetUpAndTearDownIsCalledIfSingleTestIsRun()
267: throws Exception {
268: WikiPage suitePage = crawler.addPage(root, PathParser
269: .parse("TestSuite"), classpathWidgets());
270: WikiPage testPage = crawler.addPage(suitePage, PathParser
271: .parse("TestPage"),
272: outputWritingTable("Output of TestPage"));
273: crawler.addPage(suitePage, PathParser
274: .parse(SuiteResponder.SUITE_SETUP_NAME),
275: outputWritingTable("Output of SuiteSetUp"));
276: crawler.addPage(suitePage, PathParser
277: .parse(SuiteResponder.SUITE_TEARDOWN_NAME),
278: outputWritingTable("Output of SuiteTearDown"));
279:
280: WikiPagePath testPagePath = crawler.getFullPath(testPage);
281: String resource = PathParser.render(testPagePath);
282: request.setResource(resource);
283:
284: Response response = responder.makeResponse(context, request);
285: MockResponseSender sender = new MockResponseSender(response);
286: results = sender.sentData();
287:
288: assertEquals("Output Captured", getExecutionStatusMessage());
289: assertHasRegexp("ErrorLog", results);
290:
291: WikiPage errorLog = crawler.getPage(errorLogsParentPage,
292: testPagePath);
293: String errorLogContent = errorLog.getData().getContent();
294: assertHasRegexp("Output of SuiteSetUp", errorLogContent);
295: assertHasRegexp("Output of TestPage", errorLogContent);
296: assertHasRegexp("Output of SuiteTearDown", errorLogContent);
297: }
298:
299: private String errorWritingTable(String message) {
300: return "\n|!-fitnesse.testutil.ErrorWritingFixture-!|\n" + "|"
301: + message + "|\n\n";
302:
303: }
304:
305: private String outputWritingTable(String message) {
306: return "\n|!-fitnesse.testutil.OutputWritingFixture-!|\n" + "|"
307: + message + "|\n\n";
308: }
309:
310: private String classpathWidgets() {
311: return "!path classes\n";
312: }
313:
314: private String crashFixtureTable() {
315: return "|!-fitnesse.testutil.CrashFixture-!|\n";
316: }
317:
318: private String passFixtureTable() {
319: return "|!-fitnesse.testutil.PassFixture-!|\n";
320: }
321:
322: }
|