001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.net.ftp;
018 import java.io.IOException;
019 import java.lang.reflect.Method;
020 import java.util.Arrays;
021 import java.util.Iterator;
022 import java.util.List;
023
024 import junit.framework.Test;
025 import junit.framework.TestCase;
026 import junit.framework.TestSuite;
027
028 /**
029 * A functional test suite for checking that site listings work.
030 * @author <a href="mailto:brekke@apache.org">Jeffrey D. Brekke</a>
031 * @version $Id: ListingFunctionalTest.java 636854 2008-03-13 19:55:01Z sebb $
032 */
033 public class ListingFunctionalTest extends TestCase
034 {
035 static final int HOSTNAME = 0;
036 static final int INVALID_PARSERKEY = 2;
037 static final int INVALID_PATH = 3;
038 static final int VALID_FILENAME = 4;
039 static final int VALID_PARSERKEY = 1;
040 static final int VALID_PATH = 5;
041
042 public static final Test suite()
043 {
044 String[][] testData =
045 {
046 {
047 "ftp.ibiblio.org", "unix", "vms",
048 "HA!", "javaio.jar",
049 "pub/languages/java/javafaq"
050 },
051 {
052 "ftp.wacom.com", "windows", "VMS", "HA!",
053 "wacom97.zip", "pub\\drivers"
054 },
055 {
056 "h71000.www7.hp.com", "vms", "windows",
057 "[.HA!]", "ACLOCAL.M4;1",
058
059 "[.FREEWARE50.XTERM]"
060 }
061 };
062 Class<?> clasz = ListingFunctionalTest.class;
063 Method[] methods = clasz.getDeclaredMethods();
064 TestSuite allSuites = new TestSuite("FTP Listing Functional Test Suite");
065
066 for (int i = 0; i < testData.length; i++)
067 {
068 TestSuite suite = new TestSuite(testData[i][VALID_PARSERKEY]);
069
070 for (int j = 0; j < methods.length; j++)
071 {
072 Method method = methods[j];
073
074 if (method.getName().startsWith("test"))
075 {
076 suite.addTest(new ListingFunctionalTest(
077 method.getName(),
078 testData[i]));
079 }
080 }
081
082 allSuites.addTest(suite);
083 }
084
085 return allSuites;
086 }
087
088 private FTPClient client;
089 private String hostName;
090 private String invalidParserKey;
091 private String invalidPath;
092 private String validFilename;
093 private String validParserKey;
094 private String validPath;
095
096 /**
097 * Constructor for FTPClientTest.
098 *
099 * @param arg0
100 */
101 public ListingFunctionalTest(String arg0,
102 String[] settings)
103 {
104 super(arg0);
105 invalidParserKey = settings[INVALID_PARSERKEY];
106 validParserKey = settings[VALID_PARSERKEY];
107 invalidPath = settings[INVALID_PATH];
108 validFilename = settings[VALID_FILENAME];
109 validPath = settings[VALID_PATH];
110 hostName = settings[HOSTNAME];
111 }
112
113 /**
114 * @param fileList
115 * @param string
116 *
117 * @return
118 */
119 private boolean findByName(List<?> fileList,
120 String string)
121 {
122 boolean found = false;
123 Iterator<?> iter = fileList.iterator();
124
125 while (iter.hasNext() && !found)
126 {
127 Object element = iter.next();
128
129 if (element instanceof FTPFile)
130 {
131 FTPFile file = (FTPFile) element;
132
133 found = file.getName().equals(string);
134 }
135 else
136 {
137 String filename = (String) element;
138
139 found = filename.endsWith(string);
140 }
141 }
142
143 return found;
144 }
145
146 /*
147 * @see TestCase#setUp()
148 */
149 @Override
150 protected void setUp() throws Exception
151 {
152 super.setUp();
153 client = new FTPClient();
154 client.connect(hostName);
155 client.login("anonymous", "anonymous");
156 client.enterLocalPassiveMode();
157 }
158
159 /*
160 * @see TestCase#tearDown()
161 */
162 @Override
163 protected void tearDown()
164 throws Exception
165 {
166 try
167 {
168 client.logout();
169 }
170 catch (IOException e)
171 {
172 e.printStackTrace();
173 }
174
175 if (client.isConnected())
176 {
177 client.disconnect();
178 }
179
180 client = null;
181 super.tearDown();
182 }
183
184 /*
185 * Test for FTPListParseEngine initiateListParsing()
186 */
187 public void testInitiateListParsing()
188 throws IOException
189 {
190 client.changeWorkingDirectory(validPath);
191
192 FTPListParseEngine engine = client.initiateListParsing();
193 List<FTPFile> files = Arrays.asList(engine.getNext(25));
194
195 assertTrue(files.toString(),
196 findByName(files, validFilename));
197 }
198
199 /*
200 * Test for FTPListParseEngine initiateListParsing(String, String)
201 */
202 public void testInitiateListParsingWithPath()
203 throws IOException
204 {
205 FTPListParseEngine engine = client.initiateListParsing(validParserKey,
206 validPath);
207 List<FTPFile> files = Arrays.asList(engine.getNext(25));
208
209 assertTrue(files.toString(),
210 findByName(files, validFilename));
211 }
212
213 /*
214 * Test for FTPListParseEngine initiateListParsing(String)
215 */
216 public void testInitiateListParsingWithPathAndAutodetection()
217 throws IOException
218 {
219 FTPListParseEngine engine = client.initiateListParsing(validPath);
220 List<FTPFile> files = Arrays.asList(engine.getNext(25));
221
222 assertTrue(files.toString(),
223 findByName(files, validFilename));
224 }
225
226 /*
227 * Test for FTPListParseEngine initiateListParsing(String)
228 */
229 public void testInitiateListParsingWithPathAndAutodetectionButEmpty()
230 throws IOException
231 {
232 FTPListParseEngine engine = client.initiateListParsing(invalidPath);
233
234 assertFalse(engine.hasNext());
235 }
236
237 /*
238 * Test for FTPListParseEngine initiateListParsing(String, String)
239 */
240 public void testInitiateListParsingWithPathAndIncorrectParser()
241 throws IOException
242 {
243 FTPListParseEngine engine = client.initiateListParsing(invalidParserKey,
244 invalidPath);
245
246 assertFalse(engine.hasNext());
247 }
248
249 /*
250 * Test for FTPFile[] listFiles(String, String)
251 */
252 public void testListFiles()
253 throws IOException
254 {
255 FTPClientConfig config = new FTPClientConfig(validParserKey);
256 client.configure(config);
257 List<FTPFile> files = Arrays.asList(client.listFiles(validPath));
258
259 assertTrue(files.toString(),
260 findByName(files, validFilename));
261 }
262
263 public void testListFilesWithAutodection()
264 throws IOException
265 {
266 client.changeWorkingDirectory(validPath);
267
268 List<FTPFile> files = Arrays.asList(client.listFiles());
269
270 assertTrue(files.toString(),
271 findByName(files, validFilename));
272 }
273
274 /*
275 * Test for FTPFile[] listFiles(String, String)
276 */
277 public void testListFilesWithIncorrectParser()
278 throws IOException
279 {
280 FTPClientConfig config = new FTPClientConfig(invalidParserKey);
281 client.configure(config);
282
283 FTPFile[] files = client.listFiles(validPath);
284
285 assertEquals(0, files.length);
286 }
287
288 /*
289 * Test for FTPFile[] listFiles(String)
290 */
291 public void testListFilesWithPathAndAutodectionButEmpty()
292 throws IOException
293 {
294 FTPFile[] files = client.listFiles(invalidPath);
295
296 assertEquals(0, files.length);
297 }
298
299 /*
300 * Test for FTPFile[] listFiles(String)
301 */
302 public void testListFilesWithPathAndAutodetection()
303 throws IOException
304 {
305 List<FTPFile> files = Arrays.asList(client.listFiles(validPath));
306
307 assertTrue(files.toString(),
308 findByName(files, validFilename));
309 }
310
311 /*
312 * Test for String[] listNames()
313 */
314 public void testListNames()
315 throws IOException
316 {
317 client.changeWorkingDirectory(validPath);
318
319 String[] names = client.listNames();
320
321 assertNotNull(names);
322
323 List<String> lnames = Arrays.asList(names);
324
325 assertTrue(lnames.toString(),
326 lnames.contains(validFilename));
327 }
328
329 /*
330 * Test for String[] listNames(String)
331 */
332 public void testListNamesWithPath()
333 throws IOException
334 {
335 List<String> names = Arrays.asList(client.listNames(validPath));
336
337 assertTrue(names.toString(),
338 findByName(names, validFilename));
339 }
340
341 public void testListNamesWithPathButEmpty()
342 throws IOException
343 {
344 String[] names = client.listNames(invalidPath);
345
346 assertNull(names);
347 }
348 }