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