1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.net.ftp;
18
19 import static org.junit.Assert.assertArrayEquals;
20
21 import java.io.IOException;
22 import java.lang.reflect.Method;
23 import java.util.Arrays;
24 import java.util.Iterator;
25 import java.util.List;
26
27 import org.apache.commons.lang3.ArrayUtils;
28 import org.apache.commons.net.PrintCommandListener;
29
30 import junit.framework.Test;
31 import junit.framework.TestCase;
32 import junit.framework.TestSuite;
33
34
35
36
37 public class ListingFunctionalTest extends TestCase {
38
39 static final int HOSTNAME = 0;
40 static final int VALID_PARSERKEY = 1;
41 static final int INVALID_PARSERKEY = 2;
42 static final int INVALID_PATH = 3;
43 static final int VALID_FILENAME = 4;
44 static final int VALID_PATH = 5;
45 static final int PATH_PWD = 6;
46
47 public static final Test suite() {
48 final String[][] testData = { { "ftp.ibiblio.org", "unix", "vms", "HA!", "javaio.jar", "pub/languages/java/javafaq", "/pub/languages/java/javafaq", },
49 { "apache.cs.utah.edu", "unix", "vms", "HA!", "HEADER.html", "apache.org", "/apache.org", },
50
51
52
53
54 { "ftp.decuslib.com", "vms", "windows",
55 "[.HA!]", "FREEWARE_SUBMISSION_INSTRUCTIONS.TXT;1", "[.FREEWAREV80.FREEWARE]", "DECUSLIB:[DECUS.FREEWAREV80.FREEWARE]" },
56
57
58
59
60
61 };
62 final Class<?> clasz = ListingFunctionalTest.class;
63 final Method[] methods = clasz.getDeclaredMethods();
64 final TestSuite allSuites = new TestSuite("FTP Listing Functional Test Suite");
65 for (final String[] element : testData) {
66 final TestSuite suite = new TestSuite(element[VALID_PARSERKEY] + " @ " + element[HOSTNAME]);
67 for (final Method method : methods) {
68 if (method.getName().startsWith("test")) {
69 suite.addTest(new ListingFunctionalTest(method.getName(), element));
70 }
71 }
72 allSuites.addTest(suite);
73 }
74 return allSuites;
75 }
76
77 private FTPClient client;
78 private final String hostName;
79 private final String invalidParserKey;
80 private final String invalidPath;
81 private final String validFilename;
82 private final String validParserKey;
83 private final String validPath;
84 private final String pwdPath;
85
86 public ListingFunctionalTest(final String arg0, final String[] settings) {
87 super(arg0);
88 invalidParserKey = settings[INVALID_PARSERKEY];
89 validParserKey = settings[VALID_PARSERKEY];
90 invalidPath = settings[INVALID_PATH];
91 validFilename = settings[VALID_FILENAME];
92 validPath = settings[VALID_PATH];
93 pwdPath = settings[PATH_PWD];
94 hostName = settings[HOSTNAME];
95 }
96
97 private boolean findByName(final List<?> fileList, final String string) {
98 boolean found = false;
99 final Iterator<?> iter = fileList.iterator();
100 while (iter.hasNext() && !found) {
101 final Object element = iter.next();
102 if (element instanceof FTPFile) {
103 final FTPFile file = (FTPFile) element;
104 found = file.getName().equals(string);
105 } else {
106 final String fileName = (String) element;
107 found = fileName.endsWith(string);
108 }
109 }
110 return found;
111 }
112
113
114
115
116 @Override
117 protected void setUp() throws Exception {
118 super.setUp();
119 client = new FTPClient();
120 client.addProtocolCommandListener(new PrintCommandListener(System.out));
121 client.connect(hostName);
122 client.login("anonymous", "anonymous");
123 client.enterLocalPassiveMode();
124 client.setAutodetectUTF8(true);
125 client.opts("UTF-8", "NLST");
126 }
127
128
129
130
131 @Override
132 protected void tearDown() throws Exception {
133 try {
134 client.logout();
135 } catch (final IOException e) {
136 e.printStackTrace();
137 }
138 if (client.isConnected()) {
139 client.disconnect();
140 }
141 client = null;
142 super.tearDown();
143 }
144
145
146
147
148 public void testInitiateListParsing() throws IOException {
149 client.changeWorkingDirectory(validPath);
150 final FTPListParseEngine engine = client.initiateListParsing();
151 final List<FTPFile> files = Arrays.asList(engine.getNext(25));
152 assertTrue(files.toString(), findByName(files, validFilename));
153 }
154
155
156
157
158 public void testInitiateListParsingWithPath() throws IOException {
159 final FTPListParseEngine engine = client.initiateListParsing(validParserKey, validPath);
160 final List<FTPFile> files = Arrays.asList(engine.getNext(25));
161 assertTrue(files.toString(), findByName(files, validFilename));
162 }
163
164
165
166
167 public void testInitiateListParsingWithPathAndAutodetection() throws IOException {
168 final FTPListParseEngine engine = client.initiateListParsing(validPath);
169 final List<FTPFile> files = Arrays.asList(engine.getNext(25));
170 assertTrue(files.toString(), findByName(files, validFilename));
171 }
172
173
174
175
176 public void testInitiateListParsingWithPathAndAutodetectionButEmpty() throws IOException {
177 final FTPListParseEngine engine = client.initiateListParsing(invalidPath);
178 assertFalse(engine.hasNext());
179 }
180
181
182
183
184 public void testInitiateListParsingWithPathAndIncorrectParser() throws IOException {
185 final FTPListParseEngine engine = client.initiateListParsing(invalidParserKey, invalidPath);
186 assertFalse(engine.hasNext());
187 }
188
189
190
191
192 public void testListFiles() throws IOException {
193 final FTPClientConfig config = new FTPClientConfig(validParserKey);
194 client.configure(config);
195 final List<FTPFile> files = Arrays.asList(client.listFiles(validPath));
196 assertTrue(files.toString(), findByName(files, validFilename));
197 }
198
199 public void testListFilesWithAutodection() throws IOException {
200 client.changeWorkingDirectory(validPath);
201 final List<FTPFile> files = Arrays.asList(client.listFiles());
202 assertTrue(files.toString(), findByName(files, validFilename));
203 }
204
205
206
207
208 public void testListFilesWithIncorrectParser() throws IOException {
209 final FTPClientConfig config = new FTPClientConfig(invalidParserKey);
210 client.configure(config);
211 final FTPFile[] files = client.listFiles(validPath);
212 assertNotNull(files);
213
214 assertArrayEquals("Expected empty array: " + Arrays.toString(files), new FTPFile[] {}, files);
215 }
216
217
218
219
220 public void testListFilesWithPathAndAutodectionButEmpty() throws IOException {
221 final FTPFile[] files = client.listFiles(invalidPath);
222 assertEquals(0, files.length);
223 }
224
225
226
227
228 public void testListFilesWithPathAndAutodetection() throws IOException {
229 final List<FTPFile> files = Arrays.asList(client.listFiles(validPath));
230 assertTrue(files.toString(), findByName(files, validFilename));
231 }
232
233
234
235
236 public void testListNames() throws IOException {
237 client.changeWorkingDirectory(validPath);
238 final String[] names = client.listNames();
239 assertNotNull(names);
240 final List<String> lnames = Arrays.asList(names);
241 assertTrue(lnames.toString(), lnames.contains(validFilename));
242 }
243
244
245
246
247 public void testListNamesWithPath() throws IOException {
248 final String[] listNames = client.listNames(validPath);
249 assertNotNull("listNames not null", listNames);
250 final List<String> names = Arrays.asList(listNames);
251 assertTrue(names.toString(), findByName(names, validFilename));
252 }
253
254 public void testListNamesWithPathButEmpty() throws IOException {
255 final String[] names = client.listNames(invalidPath);
256 assertTrue(ArrayUtils.isEmpty(names));
257 }
258
259 public void testPrintWorkingDirectory() throws IOException {
260 client.changeWorkingDirectory(validPath);
261 final String pwd = client.printWorkingDirectory();
262 assertEquals(pwdPath, pwd);
263 }
264 }