Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.tools.ant.taskdefs.optional.net; import static org.apache.tools.ant.AntAssert.assertContains; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.io.File; import java.io.IOException; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.Vector; import org.apache.commons.net.ftp.FTPClient; import org.apache.tools.ant.BuildEvent; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.BuildFileRule; import org.apache.tools.ant.DefaultLogger; import org.apache.tools.ant.DirectoryScanner; import org.apache.tools.ant.Project; import org.apache.tools.ant.taskdefs.condition.Os; import org.apache.tools.ant.types.FileSet; import org.apache.tools.ant.util.RetryHandler; import org.apache.tools.ant.util.Retryable; import org.apache.tools.ant.util.regexp.RegexpMatcher; import org.apache.tools.ant.util.regexp.RegexpMatcherFactory; import org.junit.After; import org.junit.Assume; import org.junit.Before; import org.junit.Rule; import org.junit.Test; //FIXME these tests are more integration than unit tests and report errors badly public class FTPTest { @Rule public BuildFileRule buildRule = new BuildFileRule(); // keep track of what operating systems are supported here. private boolean supportsSymlinks = Os.isFamily("unix"); private FTPClient ftp; private boolean loginSuceeded = false; private String loginFailureMessage; private String tmpDir = null; private String remoteTmpDir = null; private String ftpFileSep = null; private myFTP myFTPTask = new myFTP(); @Before public void setUp() { buildRule.configureProject("src/etc/testcases/taskdefs/optional/net/ftp.xml"); Project project = buildRule.getProject(); project.executeTarget("setup"); tmpDir = project.getProperty("tmp.dir"); ftp = new FTPClient(); ftpFileSep = project.getProperty("ftp.filesep"); myFTPTask.setSeparator(ftpFileSep); myFTPTask.setProject(project); remoteTmpDir = myFTPTask.resolveFile(tmpDir); String remoteHost = project.getProperty("ftp.host"); int port = Integer.parseInt(project.getProperty("ftp.port")); String remoteUser = project.getProperty("ftp.user"); String password = project.getProperty("ftp.password"); boolean connectionSucceeded = false; try { ftp.connect(remoteHost, port); connectionSucceeded = true; } catch (Exception ex) { loginFailureMessage = "could not connect to host " + remoteHost + " on port " + port; } if (connectionSucceeded) { try { ftp.login(remoteUser, password); loginSuceeded = true; } catch (IOException ioe) { loginFailureMessage = "could not log on to " + remoteHost + " as user " + remoteUser; } } } @After public void tearDown() { try { if (ftp != null) { ftp.disconnect(); } } catch (IOException ioe) { // do nothing } buildRule.getProject().executeTarget("cleanup"); } private boolean changeRemoteDir(String remoteDir) { boolean result = true; try { ftp.cwd(remoteDir); } catch (Exception ex) { System.out.println("could not change directory to " + remoteTmpDir); result = false; } return result; } @Test public void test1() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha" }); ds.scan(); compareFiles(ds, new String[] {}, new String[] { "alpha" }); } @Test public void test2() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void test3() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testFullPathMatchesCaseSensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/GAMMA.XML" }); ds.scan(); compareFiles(ds, new String[] {}, new String[] {}); } @Test public void testFullPathMatchesCaseInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setCaseSensitive(false); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/GAMMA.XML" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] {}); } @Test public void test2ButCaseInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "ALPHA/" }); ds.setCaseSensitive(false); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void test2bisButCaseInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/BETA/gamma/" }); ds.setCaseSensitive(false); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha/beta/gamma" }); } @Test public void testGetWithSelector() { buildRule.executeTarget("ftp-get-with-selector"); assertContains("selectors are not supported in remote filesets", buildRule.getLog()); FileSet fsDestination = (FileSet) buildRule.getProject() .getReference("fileset-destination-without-selector"); DirectoryScanner dsDestination = fsDestination.getDirectoryScanner(buildRule.getProject()); dsDestination.scan(); String[] sortedDestinationDirectories = dsDestination.getIncludedDirectories(); String[] sortedDestinationFiles = dsDestination.getIncludedFiles(); for (int counter = 0; counter < sortedDestinationDirectories.length; counter++) { sortedDestinationDirectories[counter] = sortedDestinationDirectories[counter] .replace(File.separatorChar, '/'); } for (int counter = 0; counter < sortedDestinationFiles.length; counter++) { sortedDestinationFiles[counter] = sortedDestinationFiles[counter].replace(File.separatorChar, '/'); } FileSet fsSource = (FileSet) buildRule.getProject().getReference("fileset-source-without-selector"); DirectoryScanner dsSource = fsSource.getDirectoryScanner(buildRule.getProject()); dsSource.scan(); compareFiles(dsSource, sortedDestinationFiles, sortedDestinationDirectories); } @Test public void testGetFollowSymlinksTrue() { Assume.assumeTrue("System does not support Symlinks", supportsSymlinks); Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("ftp-get-directory-symbolic-link"); FileSet fsDestination = (FileSet) buildRule.getProject() .getReference("fileset-destination-without-selector"); DirectoryScanner dsDestination = fsDestination.getDirectoryScanner(buildRule.getProject()); dsDestination.scan(); compareFiles(dsDestination, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testGetFollowSymlinksFalse() { Assume.assumeTrue("System does not support Symlinks", supportsSymlinks); Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("ftp-get-directory-no-symbolic-link"); FileSet fsDestination = (FileSet) buildRule.getProject() .getReference("fileset-destination-without-selector"); DirectoryScanner dsDestination = fsDestination.getDirectoryScanner(buildRule.getProject()); dsDestination.scan(); compareFiles(dsDestination, new String[] {}, new String[] {}); } @Test public void testAllowSymlinks() { Assume.assumeTrue("System does not support Symlinks", supportsSymlinks); Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("symlink-setup"); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/" }); ds.setFollowSymlinks(true); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha/beta/gamma" }); } @Test public void testProhibitSymlinks() { Assume.assumeTrue("System does not support Symlinks", supportsSymlinks); Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("symlink-setup"); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/" }); ds.setFollowSymlinks(false); ds.scan(); compareFiles(ds, new String[] {}, new String[] {}); } @Test public void testFileSymlink() { Assume.assumeTrue("System does not support Symlinks", supportsSymlinks); Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("symlink-file-setup"); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/" }); ds.setFollowSymlinks(true); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha/beta/gamma" }); } // father and child pattern test @Test public void testOrderOfIncludePatternsIrrelevant() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); String[] expectedFiles = { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }; String[] expectedDirectories = { "alpha/beta", "alpha/beta/gamma" }; FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/be?a/**", "alpha/beta/gamma/" }); ds.scan(); compareFiles(ds, expectedFiles, expectedDirectories); // redo the test, but the 2 include patterns are inverted ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/", "alpha/be?a/**" }); ds.scan(); compareFiles(ds, expectedFiles, expectedDirectories); } @Test public void testPatternsDifferInCaseScanningSensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/", "ALPHA/" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testPatternsDifferInCaseScanningInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/", "ALPHA/" }); ds.setCaseSensitive(false); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testFullpathDiffersInCaseScanningSensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/gamma.xml", "alpha/beta/gamma/GAMMA.XML" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] {}); } @Test public void testFullpathDiffersInCaseScanningInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/beta/gamma/gamma.xml", "alpha/beta/gamma/GAMMA.XML" }); ds.setCaseSensitive(false); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] {}); } @Test public void testParentDiffersInCaseScanningSensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/", "ALPHA/beta/" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testParentDiffersInCaseScanningInsensitive() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/", "ALPHA/beta/" }); ds.setCaseSensitive(false); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml" }, new String[] { "alpha", "alpha/beta", "alpha/beta/gamma" }); } @Test public void testExcludeOneFile() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "**/*.xml" }); ds.setExcludes(new String[] { "alpha/beta/b*xml" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/gamma/gamma.xml" }, new String[] {}); } @Test public void testExcludeHasPrecedence() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/**" }); ds.setExcludes(new String[] { "alpha/**" }); ds.scan(); compareFiles(ds, new String[] {}, new String[] {}); } @Test public void testAlternateIncludeExclude() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setIncludes(new String[] { "alpha/**", "alpha/beta/gamma/**" }); ds.setExcludes(new String[] { "alpha/beta/**" }); ds.scan(); compareFiles(ds, new String[] {}, new String[] { "alpha" }); } @Test public void testAlternateExcludeInclude() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setExcludes(new String[] { "alpha/**", "alpha/beta/gamma/**" }); ds.setIncludes(new String[] { "alpha/beta/**" }); ds.scan(); compareFiles(ds, new String[] {}, new String[] {}); } /** * Test inspired by Bug#1415. */ @Test public void testChildrenOfExcludedDirectory() { Assume.assumeTrue(loginFailureMessage, loginSuceeded); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); buildRule.getProject().executeTarget("children-of-excluded-dir-setup"); FTP.FTPDirectoryScanner ds = myFTPTask.newScanner(ftp); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setExcludes(new String[] { "alpha/**" }); ds.scan(); compareFiles(ds, new String[] { "delta/delta.xml" }, new String[] { "delta" }); ds = myFTPTask.newScanner(ftp); Assume.assumeTrue("Could not change remote directory", changeRemoteDir(remoteTmpDir)); ds.setBasedir(new File(buildRule.getProject().getBaseDir(), "tmp")); ds.setExcludes(new String[] { "alpha" }); ds.scan(); compareFiles(ds, new String[] { "alpha/beta/beta.xml", "alpha/beta/gamma/gamma.xml", "delta/delta.xml" }, new String[] { "alpha/beta", "alpha/beta/gamma", "delta" }); } /** * This class enables the use of the log messages as a way of testing * the number of files actually transferred. * It uses the ant regular expression mechanism to get a regex parser * to parse the log output. */ private class CountLogListener extends DefaultLogger { private Vector lastMatchGroups = null; private RegexpMatcher matcher = new RegexpMatcherFactory().newRegexpMatcher(); /** * The only constructor for a CountLogListener * @param pattern a regular expression pattern. It should have * one parenthesized group and that group should contain the * number desired. */ public CountLogListener(String pattern) { super(); this.matcher.setPattern(pattern); } /* * @param event the build event that is being logged. */ public void messageLogged(BuildEvent event) { String message = event.getMessage(); if (this.matcher.matches(message)) { lastMatchGroups = this.matcher.getGroups(message); } super.messageLogged(event); } /** * returns the desired number that results from parsing the log * message * @return the number of files indicated in the desired message or -1 * if a matching log message was never found. */ public int getCount() { if (this.lastMatchGroups == null) { return -1; } return Integer.parseInt((String) this.lastMatchGroups.get(1)); } } /** * This class enables the use of the log to count the number * of times a message has been emitted. */ private class LogCounter extends DefaultLogger { private Map searchMap = new HashMap(); private int matchCount; public void addLogMessageToSearch(String message) { searchMap.put(message, new Integer(0)); } /* * @param event the build event that is being logged. */ public void messageLogged(BuildEvent event) { String message = event.getMessage(); Integer mcnt = (Integer) searchMap.get(message); if (null != mcnt) { searchMap.put(message, new Integer(mcnt.intValue() + 1)); } super.messageLogged(event); } /** * @return the number of times that the looked for message was sent * to the log */ public int getMatchCount(String message) { Integer mcnt = (Integer) searchMap.get(message); if (null != mcnt) { return mcnt.intValue(); } return 0; } } /** * Tests the combination of the newer parameter and the * serverTimezoneConfig parameter in the PUT action. The default * configuration is an ftp server on localhost which formats * timestamps as GMT. */ @Test public void testTimezonePut() { CountLogListener log = new CountLogListener("(\\d+) files? sent"); buildRule.getProject().executeTarget("timed.test.setup"); buildRule.getProject().addBuildListener(log); buildRule.getProject().executeTarget("timed.test.put.older"); assertEquals(1, log.getCount()); } /** * Tests the combination of the newer parameter and the * serverTimezoneConfig parameter in the GET action. The default * configuration is an ftp server on localhost which formats * timestamps as GMT. */ @Test public void testTimezoneGet() { CountLogListener log = new CountLogListener("(\\d+) files? retrieved"); buildRule.getProject().executeTarget("timed.test.setup"); buildRule.getProject().addBuildListener(log); buildRule.getProject().executeTarget("timed.test.get.older"); assertEquals(3, log.getCount()); } /** * Tests that the presence of one of the server config params forces * the system type to Unix if not specified. */ @Test public void testConfiguration1() { int[] expectedCounts = { 1, 1, 0, 1, 0, 0, 0 }; performConfigTest("configuration.1", expectedCounts); } /** * Tests the systemTypeKey attribute. */ @Test public void testConfiguration2() { int[] expectedCounts = { 1, 0, 0, 1, 1, 0, 0 }; performConfigTest("configuration.2", expectedCounts); } /** * Tests the systemTypeKey attribute with UNIX specified. */ @Test public void testConfiguration3() { int[] expectedCounts = { 1, 0, 1, 0, 0, 1, 0 }; performConfigTest("configuration.3", expectedCounts); } @Test public void testConfigurationLang() { int[] expectedCounts = { 1, 1, 0, 0, 0, 0, 1 }; performConfigTest("configuration.lang.good", expectedCounts); try { performConfigTest("configuration.lang.bad", expectedCounts); fail("BuildException Expected"); } catch (Exception bx) { assertTrue(bx instanceof BuildException); } } /** * Tests the systemTypeKey attribute. */ @Test public void testConfigurationNone() { int[] expectedCounts = { 0, 0, 0, 0, 0, 0, 0 }; performConfigTest("configuration.none", expectedCounts); } private void performConfigTest(String target, int[] expectedCounts) { String[] messages = new String[] { "custom configuration", "custom config: system key = default (UNIX)", "custom config: system key = UNIX", "custom config: server time zone ID = " + buildRule.getProject().getProperty("ftp.server.timezone"), "custom config: system key = WINDOWS", "custom config: default date format = yyyy/MM/dd HH:mm", "custom config: server language code = de" }; LogCounter counter = new LogCounter(); for (int i = 0; i < messages.length; i++) { counter.addLogMessageToSearch(messages[i]); } buildRule.getProject().addBuildListener(counter); buildRule.getProject().executeTarget(target); for (int i = 0; i < messages.length; i++) { assertEquals("target " + target + ":message " + i, expectedCounts[i], counter.getMatchCount(messages[i])); } } /** * this test is inspired by a user reporting that deletions of directories with the ftp task do not work */ @Test public void testFTPDelete() { buildRule.getProject().executeTarget("ftp-delete"); } private void compareFiles(DirectoryScanner ds, String[] expectedFiles, String[] expectedDirectories) { String includedFiles[] = ds.getIncludedFiles(); String includedDirectories[] = ds.getIncludedDirectories(); assertEquals("file present: ", expectedFiles.length, includedFiles.length); assertEquals("directories present: ", expectedDirectories.length, includedDirectories.length); for (int counter = 0; counter < includedFiles.length; counter++) { includedFiles[counter] = includedFiles[counter].replace(File.separatorChar, '/'); } Arrays.sort(includedFiles); for (int counter = 0; counter < includedDirectories.length; counter++) { includedDirectories[counter] = includedDirectories[counter].replace(File.separatorChar, '/'); } Arrays.sort(includedDirectories); for (int counter = 0; counter < includedFiles.length; counter++) { assertEquals(expectedFiles[counter], includedFiles[counter]); } for (int counter = 0; counter < includedDirectories.length; counter++) { assertEquals(expectedDirectories[counter], includedDirectories[counter]); counter++; } } private static class myFTP extends FTP { public FTP.FTPDirectoryScanner newScanner(FTPClient client) { return new FTP.FTPDirectoryScanner(client); } // provide public visibility public String resolveFile(String file) { return super.resolveFile(file); } } public abstract static class myRetryableFTP extends FTP { private final int numberOfFailuresToSimulate; private int simulatedFailuresLeft; protected myRetryableFTP(int numberOfFailuresToSimulate) { this.numberOfFailuresToSimulate = numberOfFailuresToSimulate; this.simulatedFailuresLeft = numberOfFailuresToSimulate; } protected void getFile(FTPClient ftp, String dir, String filename) throws IOException, BuildException { if (this.simulatedFailuresLeft > 0) { this.simulatedFailuresLeft--; throw new IOException("Simulated failure for testing"); } super.getFile(ftp, dir, filename); } protected void executeRetryable(RetryHandler h, Retryable r, String filename) throws IOException { this.simulatedFailuresLeft = this.numberOfFailuresToSimulate; super.executeRetryable(h, r, filename); } } public static class oneFailureFTP extends myRetryableFTP { public oneFailureFTP() { super(1); } } public static class twoFailureFTP extends myRetryableFTP { public twoFailureFTP() { super(2); } } public static class threeFailureFTP extends myRetryableFTP { public threeFailureFTP() { super(3); } } public static class randomFailureFTP extends myRetryableFTP { public randomFailureFTP() { super(new Random().nextInt(Short.MAX_VALUE)); } } public void testGetWithSelectorRetryable1() { buildRule.getProject().addTaskDefinition("ftp", oneFailureFTP.class); try { buildRule.getProject().executeTarget("ftp-get-with-selector-retryable"); } catch (BuildException bx) { fail("Two retries expected, failed after one."); } } @Test public void testGetWithSelectorRetryable2() { buildRule.getProject().addTaskDefinition("ftp", twoFailureFTP.class); try { buildRule.getProject().executeTarget("ftp-get-with-selector-retryable"); } catch (BuildException bx) { fail("Two retries expected, failed after two."); } } @Test public void testGetWithSelectorRetryable3() { buildRule.getProject().addTaskDefinition("ftp", threeFailureFTP.class); try { buildRule.getProject().executeTarget("ftp-get-with-selector-retryable"); fail("Two retries expected, continued after two."); } catch (BuildException bx) { } } @Test public void testGetWithSelectorRetryableRandom() { buildRule.getProject().addTaskDefinition("ftp", randomFailureFTP.class); try { buildRule.getProject().setProperty("ftp.retries", "forever"); buildRule.getProject().executeTarget("ftp-get-with-selector-retryable"); } catch (BuildException bx) { fail("Retry forever specified, but failed."); } } @Test public void testInitialCommand() { performCommandTest("test-initial-command", new int[] { 1, 0 }); } @Test public void testSiteAction() { performCommandTest("test-site-action", new int[] { 1, 0 }); } private void performCommandTest(String target, int[] expectedCounts) { String[] messages = new String[] { "Doing Site Command: umask 222", "Failed to issue Site Command: umask 222", }; LogCounter counter = new LogCounter(); for (int i = 0; i < messages.length; i++) { counter.addLogMessageToSearch(messages[i]); } buildRule.getProject().addBuildListener(counter); buildRule.getProject().executeTarget(target); for (int i = 0; i < messages.length; i++) { assertEquals("target " + target + ":message " + i, expectedCounts[i], counter.getMatchCount(messages[i])); } } }