View Javadoc

1   /*
2    * $Id: FileUtilsTestCase.java 22592 2011-08-05 15:33:05Z pablo.kraan $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.util;
12  
13  import org.mule.tck.junit4.AbstractMuleTestCase;
14  
15  import java.io.File;
16  import java.io.IOException;
17  import java.net.URL;
18  
19  import junit.framework.TestCase;
20  import org.junit.After;
21  import org.junit.Before;
22  import org.junit.Test;
23  
24  import static org.junit.Assert.assertEquals;
25  import static org.junit.Assert.assertNotNull;
26  import static org.junit.Assert.assertTrue;
27  import static org.junit.Assert.fail;
28  
29  public class FileUtilsTestCase extends AbstractMuleTestCase
30  {
31  
32      private static final String TEST_FILE = "testFile.txt";
33      private static final String TEST_DIRECTORY = "target" + File.separator + "testDirectory";
34      private static final String UNZIPPED_FILE_PATH = TEST_DIRECTORY + File.separator +  "testFolder" + File.separator + "testFile.txt";
35  
36      private final File toDir = FileUtils.newFile(TEST_DIRECTORY);
37  
38      @Before
39      public void createDirs()
40      {
41          if (!toDir.exists())
42          {
43              toDir.mkdirs();
44          }
45      }
46  
47      @After
48      public void deleteDir()
49      {
50          toDir.delete();
51      }
52  
53      @Test
54      public void testFileTools() throws Exception
55      {
56          File file = null;
57          try
58          {
59              file = FileUtils.stringToFile(TEST_FILE, "this is a test file");
60              assertNotNull(file);
61              assertTrue(file.exists());
62  
63              file = FileUtils.stringToFile(TEST_FILE, " and this is appended content", true);
64  
65              String content = FileUtils.readFileToString(FileUtils.newFile(TEST_FILE), null);
66  
67              assertNotNull(content);
68              assertTrue(content.indexOf("this is a test file") > -1);
69              assertTrue(content.indexOf(" and this is appended content") > -1);
70  
71              file = FileUtils.newFile(TEST_FILE);
72              assertNotNull(file);
73              assertTrue(file.exists());
74  
75              file = FileUtils.createFile(TEST_FILE);
76              assertNotNull(file);
77              assertTrue(file.exists());
78  
79              file = FileUtils.createFile(TEST_FILE + "2");
80              assertNotNull(file);
81              assertTrue(file.exists());
82              assertTrue(file.canRead());
83              file.delete();
84  
85              file = FileUtils.newFile(TEST_FILE);
86              file.delete();
87  
88              File dir = FileUtils.openDirectory("src");
89              assertNotNull(dir);
90              assertTrue(dir.exists());
91              assertTrue(dir.canRead());
92              assertTrue(dir.isDirectory());
93  
94              dir = FileUtils.openDirectory("doesNotExist");
95              assertNotNull(dir);
96              assertTrue(dir.exists());
97              assertTrue(dir.canRead());
98              assertTrue(dir.isDirectory());
99              dir.delete();
100 
101         }
102         finally
103         {
104             if (file != null)
105             {
106                 file.delete();
107             }
108         }
109     }
110 
111     @Test
112     public void testFileNameTools() throws Exception
113     {
114         String filename = "Blah<Blah>.txt";
115         String result = FileUtils.prepareWinFilename(filename);
116         assertEquals("Blah(Blah).txt", result);
117 
118         filename = "Bla]h<Blah:a;b|c?d=e_f*g>.txt";
119         result = FileUtils.prepareWinFilename(filename);
120         assertEquals("Bla-h(Blah-a-b-c-d=e_f-g).txt", result);
121 
122         filename = "B\"la-h<Blah:a;b|c?d=e_f*g>.txt";
123         result = FileUtils.prepareWinFilename(filename);
124         assertEquals("B-la-h(Blah-a-b-c-d=e_f-g).txt", result);
125     }
126 
127     @Test
128     public void testDirectoryTools() throws Exception
129     {
130         File dir = FileUtils.openDirectory("src");
131         assertNotNull(dir);
132         assertTrue(dir.exists());
133         assertTrue(dir.canRead());
134         assertTrue(dir.isDirectory());
135 
136         dir = FileUtils.openDirectory("doesNotExist");
137         assertNotNull(dir);
138         assertTrue(dir.exists());
139         assertTrue(dir.canRead());
140         assertTrue(dir.isDirectory());
141         FileUtils.deleteTree(dir);
142     }
143 
144     @Test
145     public void testExtractResource() throws Exception
146     {
147         String testDir = TEST_DIRECTORY + File.separator + "Test-1";
148         File outputDir = FileUtils.newFile(testDir);
149         if (!outputDir.exists())
150         {
151             assertTrue("Failed to create output dirs.", outputDir.mkdirs());
152         }
153         String res = "META-INF/MANIFEST.MF";
154         FileUtils.extractResources(res, TestCase.class, outputDir, true);
155         File result = FileUtils.newFile(testDir, res);
156         assertNotNull(result);
157         assertTrue(result.exists());
158         assertTrue(result.canRead());
159         assertTrue(result.isFile());
160         assertTrue(result.length() > 0);
161         FileUtils.deleteTree(outputDir);
162     }
163 
164     @Test
165     public void testExtractResources() throws Exception
166     {
167         String testDir = TEST_DIRECTORY + File.separator + "Test-2";
168         File outputDir = FileUtils.newFile(testDir);
169         if (!outputDir.exists())
170         {
171             outputDir.mkdirs();
172         }
173         String res = "META-INF/";
174         FileUtils.extractResources(res, TestCase.class, outputDir, true);
175         File result = FileUtils.newFile(testDir, res);
176         assertNotNull(result);
177         assertTrue(result.exists());
178         assertTrue(result.canRead());
179         assertTrue(result.isDirectory());
180         FileUtils.deleteTree(outputDir);
181     }
182 
183     @Test
184     public void testExtractFileResource() throws Exception
185     {
186         String testDir = TEST_DIRECTORY + File.separator + "Test-3";
187         File outputDir = FileUtils.newFile(testDir);
188         if (!outputDir.exists())
189         {
190             outputDir.mkdirs();
191         }
192         String res = "org/mule/util/FileUtils.class";
193         FileUtils.extractResources(res, FileUtils.class, outputDir, true);
194         File result = FileUtils.newFile(testDir, res);
195         assertNotNull(result);
196         assertTrue(result.exists());
197         assertTrue(result.canRead());
198         assertTrue(result.isFile());
199         assertTrue(result.length() > 0);
200         FileUtils.deleteTree(outputDir);
201     }
202 
203     @Test
204     public void testExtractFileResources() throws Exception
205     {
206         String testDir = TEST_DIRECTORY + File.separator + "Test-4";
207         File outputDir = FileUtils.newFile(testDir);
208         if (!outputDir.exists())
209         {
210             outputDir.mkdirs();
211         }
212         String res = "org/mule/util/";
213         FileUtils.extractResources(res, FileUtils.class, outputDir, true);
214         File result = FileUtils.newFile(testDir, res);
215         assertNotNull(result);
216         assertTrue(result.exists());
217         assertTrue(result.canRead());
218         assertTrue(result.isDirectory());
219         FileUtils.deleteTree(outputDir);
220     }
221 
222     @Test
223     public void testExtractResourceWithoutKeepingDirStructure() throws Exception
224     {
225         String testDir = TEST_DIRECTORY + File.separator + "Test-5";
226         File outputDir = FileUtils.newFile(testDir);
227         if (!outputDir.exists())
228         {
229             outputDir.mkdirs();
230         }
231         String fileName = "MANIFEST.MF";
232         String res = "META-INF/" + fileName;
233         FileUtils.extractResources(res, TestCase.class, outputDir, false);
234         File result = FileUtils.newFile(testDir, fileName);
235         assertNotNull(result);
236         assertTrue(result.exists());
237         assertTrue(result.canRead());
238         assertTrue(result.isFile());
239         assertTrue(result.length() > 0);
240         FileUtils.deleteTree(outputDir);
241     }
242 
243     @Test
244     public void testExtractResourcesWithoutKeepingDirStructure() throws Exception
245     {
246         String testDir = TEST_DIRECTORY + File.separator + "Test-6";
247         File outputDir = FileUtils.newFile(testDir);
248         if (!outputDir.exists())
249         {
250             outputDir.mkdirs();
251         }
252         String fileName = "util/FileUtilsTestCase.class";
253         String res = "org/mule/";
254         FileUtils.extractResources(res, FileUtilsTestCase.class, outputDir, false);
255         File result = FileUtils.newFile(testDir, fileName);
256         assertNotNull(result);
257         assertTrue(result.exists());
258         assertTrue(result.canRead());
259         assertTrue(result.isFile());
260         assertTrue(result.length() > 0);
261         FileUtils.deleteTree(outputDir);
262     }
263 
264     @Test
265     public void testExtractFileResourceWithoutKeepingDirStructure() throws Exception
266     {
267         String testDir = TEST_DIRECTORY + File.separator + "Test-7";
268         File outputDir = FileUtils.newFile(testDir);
269         if (!outputDir.exists())
270         {
271             outputDir.mkdirs();
272         }
273         String fileName = "FileUtils.class";
274         String res = "org/mule/util/" + fileName;
275         FileUtils.extractResources(res, FileUtils.class, outputDir, false);
276         File result = FileUtils.newFile(testDir, fileName);
277         assertNotNull(result);
278         assertTrue(result.exists());
279         assertTrue(result.canRead());
280         assertTrue(result.isFile());
281         assertTrue(result.length() > 0);
282         FileUtils.deleteTree(outputDir);
283     }
284 
285     @Test
286     public void testExtractFileResourcesWithoutKeepingDirStructure() throws Exception
287     {
288         String testDir = TEST_DIRECTORY + File.separator + "Test-8";
289         File outputDir = FileUtils.newFile(testDir);
290         if (!outputDir.exists())
291         {
292             outputDir.mkdirs();
293         }
294         String fileName = "util/FileUtilsTestCase.class";
295         String res = "org/mule/";
296         FileUtils.extractResources(res, FileUtilsTestCase.class, outputDir, false);
297         File result = FileUtils.newFile(testDir, fileName);
298         assertNotNull(result);
299         assertTrue(result.exists());
300         assertTrue(result.canRead());
301         assertTrue(result.isFile());
302         assertTrue(result.length() > 0);
303         FileUtils.deleteTree(outputDir);
304     }
305 
306     @Test
307     public void testDeleteTreeWithIgnoredDirectories() throws Exception
308     {
309         final String testDir = TEST_DIRECTORY + File.separator + "Test-deleting";
310         File outputDir = FileUtils.newFile(testDir);
311         if (!outputDir.exists())
312         {
313             outputDir.mkdirs();
314         }
315 
316         File toBeDeleted1 = FileUtils.newFile(outputDir, "toBeDeleted1/");
317         toBeDeleted1.mkdirs();
318         File toBeDeleted2 = FileUtils.newFile(outputDir, "toBeDeleted2/");
319         toBeDeleted2.mkdirs();
320 
321         File keepMeIntact = FileUtils.newFile(outputDir, "keepMeIntact/");
322         keepMeIntact.mkdirs();
323 
324         FileUtils.deleteTree(outputDir, new String[] {"keepMeIntact"});
325 
326         assertTrue("Shouldn't have been deleted.", keepMeIntact.exists());
327 
328         FileUtils.deleteTree(outputDir);
329     }
330 
331     @Test
332     public void testRenameFile()
333     {
334         try
335         {
336             File sourceFile = createTestFile("source");
337             File destFile = createTestFile("dest");
338 
339             assertTrue(destFile.delete());
340             assertTrue(FileUtils.renameFile(sourceFile, destFile));
341             assertTrue(destFile.exists());
342             assertTrue(destFile.delete());
343         }
344         catch (Exception e)
345         {
346             fail(e.getMessage());
347         }
348     }
349 
350     @Test
351     public void testRenameFileAcrossFolders()
352     {
353         try
354         {
355             File dir = createTestDir("test");
356             File sourceFile = createTestFile("source");
357             File destFile = new File(dir, "dest");
358 
359             assertTrue(FileUtils.renameFile(sourceFile, destFile));
360             assertTrue(destFile.exists());
361             assertTrue(destFile.delete());
362             assertTrue(dir.delete());
363         }
364         catch (Exception e)
365         {
366             fail(e.getMessage());
367         }
368     }
369 
370     @Test
371     public void testUnzipFileToSameFolderTwice() throws Exception
372     {
373         URL resourceAsUrl = IOUtils.getResourceAsUrl("testFolder.zip", getClass());
374         File zipFile = new File(resourceAsUrl.getFile());
375         File outputDir = FileUtils.newFile(TEST_DIRECTORY);
376 
377         for (int i = 0; i < 2; i++)
378         {
379             FileUtils.unzip(zipFile, outputDir);
380             File testFile = new File(UNZIPPED_FILE_PATH);
381             assertTrue(testFile.exists());
382         }
383     }
384 
385     private File createTestFile(String filePath) throws IOException
386     {
387         return File.createTempFile(filePath, ".junit");
388     }
389     
390     private File createTestDir(String dirPath) throws IOException
391     {
392         File file = createTestFile(dirPath);
393         file.delete();
394         file.mkdir();
395         return file;
396     }
397 }