001: // Copyright © 2002-2005 Canoo Engineering AG, Switzerland.
002: package com.canoo.webtest.engine;
003:
004: import java.io.File;
005: import java.util.ArrayList;
006: import java.util.List;
007:
008: import junit.framework.TestCase;
009:
010: import org.apache.commons.httpclient.Credentials;
011: import org.apache.commons.httpclient.auth.BasicScheme;
012: import org.apache.commons.httpclient.auth.CredentialsNotAvailableException;
013: import org.apache.tools.ant.BuildException;
014: import org.apache.tools.ant.Project;
015: import org.apache.tools.ant.RuntimeConfigurable;
016: import org.apache.tools.ant.taskdefs.Echo;
017:
018: import com.canoo.webtest.ant.WebtestTask;
019: import com.canoo.webtest.self.TestBlock;
020: import com.canoo.webtest.self.ThrowAssert;
021: import com.canoo.webtest.steps.Step;
022: import com.gargoylesoftware.htmlunit.BrowserVersion;
023: import com.gargoylesoftware.htmlunit.DefaultCredentialsProvider;
024: import com.gargoylesoftware.htmlunit.WebClient;
025:
026: /**
027: * Tests for {@link Configuration}.
028: *
029: * @author unknown
030: * @author Marc Guillemot
031: * @author Paul King
032: */
033: public class ConfigurationTest extends TestCase {
034: static final String[] PROPERTIES_BOOL = { "autorefresh",
035: "haltonerror", "haltonfailure", "saveresponse",
036: "showhtmlparseroutput", "summary" };
037: static final String[] PROPERTIES_STRING = { "basepath",
038: "errorproperty", "failureproperty", "host", "resultpath",
039: "saveprefix" };
040: static final String[] PROPERTIES_INT = { "timeout", "port" };
041:
042: public void testCtorBasePath() {
043: String host = "somehost";
044: int port = 10;
045: String basePath = "somepath";
046:
047: Configuration simpleConfig = new Configuration();
048:
049: simpleConfig.setHost(host);
050: simpleConfig.setPort(port);
051: simpleConfig.setBasepath(basePath);
052:
053: assertEquals("host", host, simpleConfig.getHost());
054: assertEquals("port", port, simpleConfig.getPort());
055: assertEquals("protocol", Configuration.PROTOCOL_HTTP,
056: simpleConfig.getProtocol());
057: assertEquals("base path", basePath, simpleConfig.getBasePath());
058: }
059:
060: public void testCtorDefaultPage() {
061: // String defaultProtocol = "http";
062: String host = "xxx";
063: int port = 10;
064: String basePath = "frontnet";
065: // String baseUrl = defaultProtocol + "://" + host + ":" + port;
066: // String defaultPage = "start.html";
067: // String defaultPageUrl = baseUrl + "/" + basePath + "/" + defaultPage;
068:
069: Configuration conf = new Configuration();
070:
071: conf.setHost(host);
072: conf.setPort(port);
073: conf.setBasepath(basePath);
074:
075: assertEquals("base path", basePath, conf.getBasePath());
076: }
077:
078: public void testStandard() {
079: Configuration standard = new Configuration();
080:
081: assertEquals("port", Configuration.PORT_HTTP, standard
082: .getPort());
083: assertEquals("protocol", Configuration.PROTOCOL_HTTP, standard
084: .getProtocol());
085: assertEquals("host", Configuration.DEFAULT_HOST, standard
086: .getHost());
087: assertFalse("saveResp", standard.isSaveResponse());
088: assertFalse("summary", standard.isSummary());
089:
090: assertNotNull("urlForPage", standard.getUrlForPage(null));
091:
092: assertNull("basePath", standard.getBasePath());
093: assertNull("errorProperty", standard.getErrorProperty());
094: assertNull("failureProperty", standard.getFailureProperty());
095: }
096:
097: public void testErrorAndFailureProperties() {
098: Configuration propConf = new Configuration();
099:
100: propConf.setErrorProperty("errorProp");
101: propConf.setFailureProperty("failureProp");
102: assertNotNull("errorProperty", propConf.getErrorProperty());
103: assertNotNull("failureProperty", propConf.getFailureProperty());
104: }
105:
106: public void testDefaultPropertyType() {
107: Configuration propConf = new Configuration();
108:
109: propConf.setDefaultPropertyType(Step.PROPERTY_TYPE_ANT);
110: assertEquals(Step.PROPERTY_TYPE_ANT, propConf
111: .getDefaultPropertyType());
112: }
113:
114: public void testGetUrlForPage() {
115: Configuration config = new Configuration();
116:
117: config.setHost("myHost");
118: config.setBasepath("/myApplication");
119:
120: assertEquals("http://myHost/myApplication", config
121: .getUrlForPage(""));
122:
123: config.setProtocol("https");
124: config.setPort(443);
125: assertEquals("https://myHost/myApplication", config
126: .getUrlForPage(""));
127:
128: assertEquals("https://myHost/myApplication", config
129: .getUrlForPage("https://myHost/myApplication"));
130: assertEquals("http://myHost/myPage", config
131: .getUrlForPage("http://myHost/myPage"));
132: assertEquals("file://myFile", config
133: .getUrlForPage("file://myFile"));
134: }
135:
136: public void testUrlFromHostPort() {
137: Configuration hostPortConfig = new Configuration();
138:
139: hostPortConfig.setHost("somehost");
140: hostPortConfig.setPort(8080);
141:
142: String expectedUrl = "http://somehost:8080/somepage.html";
143:
144: assertEquals("urlForPage", expectedUrl, hostPortConfig
145: .getUrlForPage("somepage.html"));
146: assertEquals("urlForPage", expectedUrl, hostPortConfig
147: .getUrlForPage("/somepage.html"));
148: }
149:
150: public void testUrlFromHostWitheEfaultPort() {
151: Configuration hostPortConfig = new Configuration();
152:
153: hostPortConfig.setHost("somehost");
154: assertEquals("urlForPage", "http://somehost/somepage.html",
155: hostPortConfig.getUrlForPage("somepage.html"));
156:
157: hostPortConfig.setProtocol("https");
158: hostPortConfig.setPort(443);
159: assertEquals("urlForPage", "https://somehost/somepage.html",
160: hostPortConfig.getUrlForPage("somepage.html"));
161: }
162:
163: public void testUrlFromHostPortBasePath() {
164: Configuration basePathConfig = new Configuration();
165:
166: basePathConfig.setHost("somehost");
167: basePathConfig.setPort(8080);
168: basePathConfig.setBasepath("somepath");
169:
170: String expectedUrl = "http://somehost:8080/somepath/somepage.html";
171:
172: assertEquals(expectedUrl, basePathConfig
173: .getUrlForPage("somepage.html"));
174: assertEquals(expectedUrl, basePathConfig
175: .getUrlForPage("/somepage.html"));
176:
177: basePathConfig.setBasepath("/somepath");
178: assertEquals(expectedUrl, basePathConfig
179: .getUrlForPage("somepage.html"));
180: assertEquals(expectedUrl, basePathConfig
181: .getUrlForPage("/somepage.html"));
182:
183: basePathConfig.setBasepath("/somepath/");
184: assertEquals(expectedUrl, basePathConfig
185: .getUrlForPage("somepage.html"));
186: assertEquals(expectedUrl, basePathConfig
187: .getUrlForPage("/somepage.html"));
188: }
189:
190: public void testUrlFromFileDosPageWithBasepath() {
191: Configuration fileConfig = new Configuration();
192:
193: fileConfig.setProtocol("file");
194: fileConfig.setBasepath("C:/temp");
195: assertEquals("page", "file:/C:/temp/XX.xx", fileConfig
196: .getUrlForPage("XX.xx"));
197: }
198:
199: public void testUrlFromFileUnixPageWithBasepath() {
200: Configuration fileConfig = new Configuration();
201:
202: fileConfig.setProtocol("file");
203: fileConfig.setBasepath("/temp");
204: assertEquals("", "file:/temp/XX.xx", fileConfig
205: .getUrlForPage("XX.xx"));
206: }
207:
208: public void testUrlFromFileDosPageAbsolute() {
209: Configuration fileConfig = new Configuration();
210:
211: fileConfig.setProtocol("file");
212: fileConfig.setBasepath("/");
213: assertEquals("", "file:/c:/temp/XX.xx", fileConfig
214: .getUrlForPage("c:/temp/XX.xx"));
215: }
216:
217: public void testUrlFromFileDosPageAbsoluteNoBasePath() {
218: Configuration fileConfig = new Configuration();
219:
220: fileConfig.setProtocol("file");
221: assertEquals("", "file:/c:/temp/XX.xx", fileConfig
222: .getUrlForPage("c:/temp/XX.xx"));
223: }
224:
225: public void testUrlFromFileDosPageRelative() {
226: Configuration fileConfig = new Configuration();
227:
228: fileConfig.setProtocol("file");
229: fileConfig.setBasepath("c:/temp");
230: assertEquals("", "file:/c:/temp/XX.xx", fileConfig
231: .getUrlForPage("XX.xx"));
232: }
233:
234: public void testUrlFromFileUnixPageRelative() {
235: Configuration fileConfig = new Configuration();
236:
237: fileConfig.setProtocol("file");
238: fileConfig.setBasepath("/");
239: assertEquals("", "file:/temp/XX.xx", fileConfig
240: .getUrlForPage("temp/XX.xx"));
241: }
242:
243: public void testNoPropertyHandler() {
244: ThrowAssert.assertThrows(IllegalStateException.class,
245: new TestBlock() {
246: public void call() throws Exception {
247: Configuration fileConfig = new Configuration();
248:
249: fileConfig.setPropertyHandler(null);
250: fileConfig.getExternalProperty("some property");
251: }
252: });
253: }
254:
255: public void testResultDirNotDirectoryThrowsBuildException() {
256: final Configuration config = new Configuration();
257: config.setSummary(true);
258: final File nonDirFile = new File("dummy") {
259: public boolean exists() {
260: return true;
261: }
262:
263: public boolean isDirectory() {
264: return false;
265: }
266: };
267: ThrowAssert.assertThrows(BuildException.class,
268: "Result dir is not a directory", new TestBlock() {
269: public void call() throws Throwable {
270: config.prepareResultDir(nonDirFile);
271: }
272: });
273: }
274:
275: public void testCantCreateResultDirThrowsBuildException() {
276: final File cantCreateDir = new File("dummy") {
277: public boolean exists() {
278: return false;
279: }
280:
281: public boolean mkdirs() {
282: return false;
283: }
284: };
285: final Configuration config = new Configuration() {
286: protected File computeSubFolder(File _resultDir) {
287: return cantCreateDir;
288: }
289: };
290: config.setSummary(true);
291: ThrowAssert.assertThrows(BuildException.class,
292: "Failed to create result dir", new TestBlock() {
293: public void call() throws Throwable {
294: config.prepareResultDir(cantCreateDir);
295: }
296: });
297: }
298:
299: public void testComputeSubFolder() {
300: final List files = new ArrayList();
301: final File reportBaseDir = new File("dummy") {
302: public File[] listFiles() {
303: return (File[]) files.toArray(new File[] {});
304: }
305: };
306: final WebtestTask webTest = new WebtestTask();
307: final Context context = new Context(webTest);
308: Configuration config = new Configuration();
309: config.setContext(context);
310:
311: webTest.setName("foo");
312: assertEquals(1, config.getResultFolderIndex(reportBaseDir));
313: assertEquals("001_Foo", config.computeSubFolder(reportBaseDir)
314: .getName());
315:
316: webTest.setName("first test - blabla");
317: assertEquals(1, config.getResultFolderIndex(reportBaseDir));
318: assertEquals("001_FirstTestBlabla", config.computeSubFolder(
319: reportBaseDir).getName());
320:
321: files.add(new File("001_blabla"));
322: config.setResultFolderIndex(-1); // force to compute
323: assertEquals(2, config.getResultFolderIndex(reportBaseDir));
324: assertEquals("002_FirstTestBlabla", config.computeSubFolder(
325: reportBaseDir).getName());
326:
327: files.add(new File("002_Xdkf"));
328: files.add(new File("003_Zfkss"));
329: files.add(new File("029_AnotherTest"));
330: config.setResultFolderIndex(-1); // force to compute
331: assertEquals(30, config.getResultFolderIndex(reportBaseDir));
332: assertEquals("030_FirstTestBlabla", config.computeSubFolder(
333: reportBaseDir).getName());
334:
335: // listFiles returns null "if this abstract pathname does not denote a directory"
336: final File reportBaseDir2 = new File("dummy") {
337: public File[] listFiles() {
338: return null;
339: }
340: };
341: config.setResultFolderIndex(-1); // force to compute
342: assertEquals("001_FirstTestBlabla", config.computeSubFolder(
343: reportBaseDir2).getName());
344: }
345:
346: public void testNoProxyHandling()
347: throws CredentialsNotAvailableException {
348: assertNull(getCredentials());
349: }
350:
351: public void testProxyHandling()
352: throws CredentialsNotAvailableException {
353: System.setProperty("http.proxyUser", "user");
354: System.setProperty("http.proxyPassword", "password");
355: assertNotNull(getCredentials());
356: }
357:
358: public void testDefaultPropertiesFromProject_NoConfig() {
359: final Project project = new Project();
360:
361: setProperties(project, "wt.config.", PROPERTIES_BOOL, "true");
362: setProperties(project, "wt.config.", PROPERTIES_STRING,
363: "blabla");
364: setProperties(project, "wt.config.", PROPERTIES_INT, "1234");
365: project.setProperty("wt.config.protocol", "https");
366: project.setProperty("wt.config.defaultpropertytype", "ant");
367:
368: WebtestTask webTest = new WebtestTask();
369: webTest.setProject(project);
370: webTest.addTask(new Echo()); // just to trigger creation of default config
371:
372: Configuration config = webTest.getConfig();
373: verifyProperties(config, true, 1234, "blabla", "https", "ant");
374:
375: // change property values to be sure that this info is considered
376: setProperties(project, "wt.config.", PROPERTIES_BOOL, "false");
377: setProperties(project, "wt.config.", PROPERTIES_STRING, "foo");
378: setProperties(project, "wt.config.", PROPERTIES_INT, "4321");
379: project.setProperty("wt.config.protocol", "http");
380: project.setProperty("wt.config.defaultpropertytype", "dynamic");
381:
382: webTest = new WebtestTask();
383: webTest.setProject(project);
384: webTest.addTask(new Echo()); // just to trigger creation of default config
385:
386: config = webTest.getConfig();
387: verifyProperties(config, false, 4321, "foo", "http", "dynamic");
388: }
389:
390: public void testDefaultPropertiesFromProject_ConfigUsed() {
391: final Project project = new Project();
392:
393: setProperties(project, "wt.config.", PROPERTIES_BOOL, "true");
394: setProperties(project, "wt.config.", PROPERTIES_STRING,
395: "blabla");
396: setProperties(project, "wt.config.", PROPERTIES_INT, "1234");
397: project.setProperty("wt.config.protocol", "https");
398: project.setProperty("wt.config.defaultpropertytype", "ant");
399:
400: WebtestTask webTest = new WebtestTask();
401: webTest.setProject(project);
402:
403: final RuntimeConfigurable rc = new RuntimeConfigurable(null,
404: "config");
405: rc.setAttribute("host", "myHost");
406: rc.setAttribute("port", "8080");
407: Configuration config = new Configuration();
408: config.setProject(project);
409: config.setRuntimeConfigurableWrapper(rc);
410: config.setHost("myHost");
411: config.setPort(8080);
412: config.init();
413: webTest.addConfig(config);
414:
415: // test some properties that have been set form project's properties
416: assertEquals(true, config.isHaltOnError());
417: assertEquals(true, config.isShowHtmlParserOutput());
418: assertEquals(1234, config.getTimeout());
419: assertEquals("blabla", config.getBasePath());
420: assertEquals("blabla", config.getFailureProperty());
421:
422: // but that the ones explicitely configured haven't been overwritten
423: assertEquals("myHost", config.getHost());
424: assertEquals(8080, config.getPort());
425: }
426:
427: private void verifyProperties(final Configuration config,
428: final boolean bValue, final int intValue,
429: final String strValue, final String protocol,
430: final String propertyType) {
431: assertEquals("autorefresh", String.valueOf(bValue), config
432: .getAutoRefresh());
433: assertEquals("haltonerror", bValue, config.isHaltOnError());
434: assertEquals("haltonfailure", bValue, config.isHaltOnFailure());
435: assertEquals("saveresponse", bValue, config.isSaveResponse());
436: assertEquals("showhtmlparseroutput", bValue, config
437: .isShowHtmlParserOutput());
438: assertEquals("summary", bValue, config.isSummary());
439:
440: assertEquals("port", intValue, config.getPort());
441: assertEquals("timeout", intValue, config.getTimeout());
442:
443: assertEquals("basepath", strValue, config.getBasePath());
444: assertEquals("errorproperty", strValue, config
445: .getErrorProperty());
446: assertEquals("failureproperty", strValue, config
447: .getFailureProperty());
448: assertEquals("host", strValue, config.getHost());
449: assertEquals("resultpath", strValue, config.getResultpath()
450: .getName());
451: assertEquals("saveprefix", strValue, config.getSavePrefix());
452:
453: assertEquals("protocol", protocol, config.getProtocol());
454: assertEquals("defaultpropertytype", propertyType, config
455: .getDefaultPropertyType());
456: }
457:
458: /**
459: * Set the values on all properties
460: */
461: private void setProperties(final Project project,
462: final String prefix, final String[] properties,
463: final String value) {
464: for (int i = 0; i < properties.length; i++) {
465: project.setProperty(prefix + properties[i], value);
466: }
467:
468: assertEquals(value, project.getProperty(prefix + properties[0])); // just to test that it has been set
469: }
470:
471: private static Credentials getCredentials()
472: throws CredentialsNotAvailableException {
473: System.setProperty("http.proxyHost", "dummyHost");
474: WebClient wc = Configuration
475: .setupWebClient(BrowserVersion.INTERNET_EXPLORER_6_0);
476: return wc.getCredentialsProvider().getCredentials(
477: new BasicScheme(), "dummyHost", 80, true);
478: }
479:
480: public void testProxySettings() {
481: System.setProperty("http.proxyHost", "dummyHost");
482: System.setProperty("http.nonProxyHosts",
483: "myhost.mydomain|*.myotherdomain.com");
484: final List proxyBypassPatterns = new ArrayList();
485: final WebClient webClient = new WebClient() {
486: public void addHostsToProxyBypass(final String _pattern) {
487: proxyBypassPatterns.add(_pattern);
488: super .addHostsToProxyBypass(_pattern);
489: }
490: };
491: final DefaultCredentialsProvider credentialProvider = new DefaultCredentialsProvider();
492: Configuration.configureProxy(webClient, credentialProvider);
493: assertEquals(2, proxyBypassPatterns.size());
494: assertEquals("myhost\\.mydomain", proxyBypassPatterns.get(0));
495: assertEquals(".*\\.myotherdomain\\.com", proxyBypassPatterns
496: .get(1));
497: }
498: }
|