1   /*
2    * Copyright 2004 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.commons.net.ftp;
17  import java.io.IOException;
18  import java.lang.reflect.Method;
19  import java.util.Arrays;
20  import java.util.Iterator;
21  import java.util.List;
22  
23  import junit.framework.Test;
24  import junit.framework.TestCase;
25  import junit.framework.TestSuite;
26  
27  /**
28   * A functional test suite for checking that site listings work.
29   * @author <a href="mailto:brekke@apache.org">Jeffrey D. Brekke</a>
30   * @version $Id: ListingFunctionalTest.java 167953 2005-05-03 18:29:42Z dfs $
31   */
32  public class ListingFunctionalTest extends TestCase
33  {
34      static final int HOSTNAME = 0;
35      static final int INVALID_PARSERKEY = 2;
36      static final int INVALID_PATH = 3;
37      static final int VALID_FILENAME = 4;
38      static final int VALID_PARSERKEY = 1;
39      static final int VALID_PATH = 5;
40  
41      public static final Test suite()
42      {
43          String[][] testData =
44              {
45                  {
46                      "ftp.ibiblio.org", "unix", "vms",
47                      "HA!", "javaio.jar",
48                      "pub/languages/java/javafaq"
49                  },
50                  {
51                      "ftp.wacom.com", "windows", "VMS", "HA!",
52                      "wacom97.zip", "pub\\ftp\\drivers"
53                  },
54                  {
55                      "h71000.www7.hp.com", "vms", "windows",
56                      "[.HA!]", "ACLOCAL.M4;1",
57  
58                      "[.FREEWARE50.XTERM]"
59                  }
60              };
61          Class clasz = ListingFunctionalTest.class;
62          Method[] methods = clasz.getDeclaredMethods();
63          TestSuite allSuites = new TestSuite("FTP Listing Functional Test Suite");
64  
65          for (int i = 0; i < testData.length; i++)
66          {
67              TestSuite suite = new TestSuite(testData[i][VALID_PARSERKEY]);
68  
69              for (int j = 0; j < methods.length; j++)
70              {
71                  Method method = methods[j];
72  
73                  if (method.getName().startsWith("test"))
74                  {
75                      suite.addTest(new ListingFunctionalTest(
76                                                              method.getName(),
77                                                              testData[i]));
78                  }
79              }
80  
81              allSuites.addTest(suite);
82          }
83  
84          return allSuites;
85      }
86  
87      private FTPClient client;
88      private String hostName;
89      private String invalidParserKey;
90      private String invalidPath;
91      private String validFilename;
92      private String validParserKey;
93      private String validPath;
94  
95      /**
96       * Constructor for FTPClientTest.
97       *
98       * @param arg0
99       */
100     public ListingFunctionalTest(String arg0,
101                                  String[] settings)
102     {
103         super(arg0);
104         invalidParserKey = settings[INVALID_PARSERKEY];
105         validParserKey = settings[VALID_PARSERKEY];
106         invalidPath = settings[INVALID_PATH];
107         validFilename = settings[VALID_FILENAME];
108         validPath = settings[VALID_PATH];
109         hostName = settings[HOSTNAME];
110     }
111 
112     /**
113      * @param fileList
114      * @param string
115      *
116      * @return
117      */
118     private boolean findByName(List fileList,
119                                String string)
120     {
121         boolean found = false;
122         Iterator iter = fileList.iterator();
123 
124         while (iter.hasNext() && !found)
125         {
126             Object element = iter.next();
127 
128             if (element instanceof FTPFile)
129             {
130                 FTPFile file = (FTPFile) element;
131 
132                 found = file.getName().equals(string);
133             }
134             else
135             {
136                 String filename = (String) element;
137 
138                 found = filename.endsWith(string);
139             }
140         }
141 
142         return found;
143     }
144 
145     /*
146      * @see TestCase#setUp()
147      */
148     protected void setUp() throws Exception
149     {
150         super.setUp();
151         client = new FTPClient();
152         client.connect(hostName);
153         client.login("anonymous", "anonymous");
154         client.enterLocalPassiveMode();
155     }
156 
157     /*
158      * @see TestCase#tearDown()
159      */
160     protected void tearDown()
161         throws Exception
162     {
163         try
164         {
165             client.logout();
166         }
167         catch (IOException e)
168         {
169             e.printStackTrace();
170         }
171 
172         if (client.isConnected())
173         {
174             client.disconnect();
175         }
176 
177         client = null;
178         super.tearDown();
179     }
180 
181     /*
182      * Test for FTPListParseEngine initiateListParsing()
183      */
184     public void testInitiateListParsing()
185         throws IOException
186     {
187         client.changeWorkingDirectory(validPath);
188 
189         FTPListParseEngine engine = client.initiateListParsing();
190         List files = Arrays.asList(engine.getNext(25));
191 
192         assertTrue(files.toString(),
193                    findByName(files, validFilename));
194     }
195 
196     /*
197      * Test for FTPListParseEngine initiateListParsing(String, String)
198      */
199     public void testInitiateListParsingWithPath()
200         throws IOException
201     {
202         FTPListParseEngine engine = client.initiateListParsing(validParserKey,
203                                                                validPath);
204         List files = Arrays.asList(engine.getNext(25));
205 
206         assertTrue(files.toString(),
207                    findByName(files, validFilename));
208     }
209 
210     /*
211      * Test for FTPListParseEngine initiateListParsing(String)
212      */
213     public void testInitiateListParsingWithPathAndAutodetection()
214         throws IOException
215     {
216         FTPListParseEngine engine = client.initiateListParsing(validPath);
217         List files = Arrays.asList(engine.getNext(25));
218 
219         assertTrue(files.toString(),
220                    findByName(files, validFilename));
221     }
222 
223     /*
224      * Test for FTPListParseEngine initiateListParsing(String)
225      */
226     public void testInitiateListParsingWithPathAndAutodetectionButEmpty()
227         throws IOException
228     {
229         FTPListParseEngine engine = client.initiateListParsing(invalidPath);
230 
231         assertFalse(engine.hasNext());
232     }
233 
234     /*
235      * Test for FTPListParseEngine initiateListParsing(String, String)
236      */
237     public void testInitiateListParsingWithPathAndIncorrectParser()
238         throws IOException
239     {
240         FTPListParseEngine engine = client.initiateListParsing(invalidParserKey,
241                                                                invalidPath);
242 
243         assertFalse(engine.hasNext());
244     }
245 
246     /*
247      * Test for FTPFile[] listFiles(String, String)
248      */
249     public void testListFiles()
250         throws IOException
251     {
252         FTPClientConfig config = new FTPClientConfig(validParserKey);
253         client.configure(config);
254         List files = Arrays.asList(client.listFiles(validPath));
255 
256         assertTrue(files.toString(),
257                    findByName(files, validFilename));
258     }
259 
260     public void testListFilesWithAutodection()
261         throws IOException
262     {
263         client.changeWorkingDirectory(validPath);
264 
265         List files = Arrays.asList(client.listFiles());
266 
267         assertTrue(files.toString(),
268                    findByName(files, validFilename));
269     }
270 
271     /*
272      * Test for FTPFile[] listFiles(String, String)
273      */
274     public void testListFilesWithIncorrectParser()
275         throws IOException
276     {
277         FTPClientConfig config = new FTPClientConfig(invalidParserKey);
278         client.configure(config);
279 
280         FTPFile[] files = client.listFiles(validPath);
281 
282         assertEquals(0, files.length);
283     }
284 
285     /*
286      * Test for FTPFile[] listFiles(String)
287      */
288     public void testListFilesWithPathAndAutodectionButEmpty()
289         throws IOException
290     {
291         FTPFile[] files = client.listFiles(invalidPath);
292 
293         assertEquals(0, files.length);
294     }
295 
296     /*
297      * Test for FTPFile[] listFiles(String)
298      */
299     public void testListFilesWithPathAndAutodetection()
300         throws IOException
301     {
302         List files = Arrays.asList(client.listFiles(validPath));
303 
304         assertTrue(files.toString(),
305                    findByName(files, validFilename));
306     }
307 
308     /*
309      * Test for String[] listNames()
310      */
311     public void testListNames()
312         throws IOException
313     {
314         client.changeWorkingDirectory(validPath);
315 
316         String[] names = client.listNames();
317 
318         assertNotNull(names);
319 
320         List lnames = Arrays.asList(names);
321 
322         assertTrue(lnames.toString(),
323                    lnames.contains(validFilename));
324     }
325 
326     /*
327      * Test for String[] listNames(String)
328      */
329     public void testListNamesWithPath()
330         throws IOException
331     {
332         List names = Arrays.asList(client.listNames(validPath));
333 
334         assertTrue(names.toString(),
335                    findByName(names, validFilename));
336     }
337 
338     public void testListNamesWithPathButEmpty()
339         throws IOException
340     {
341         String[] names = client.listNames(invalidPath);
342 
343         assertNull(names);
344     }
345 }