View Javadoc
1   /*
2    * The MIT License
3    *
4    * Copyright (c) 2004, The Codehaus
5    *
6    * Permission is hereby granted, free of charge, to any person obtaining a copy of
7    * this software and associated documentation files (the "Software"), to deal in
8    * the Software without restriction, including without limitation the rights to
9    * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
10   * of the Software, and to permit persons to whom the Software is furnished to do
11   * so, subject to the following conditions:
12   *
13   * The above copyright notice and this permission notice shall be included in all
14   * copies or substantial portions of the Software.
15   *
16   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22   * SOFTWARE.
23   */
24  package org.codehaus.plexus.archiver.manager;
25  
26  import java.io.File;
27  import java.util.stream.Collectors;
28  import java.util.stream.Stream;
29  
30  import org.codehaus.plexus.archiver.Archiver;
31  import org.codehaus.plexus.archiver.TestSupport;
32  import org.codehaus.plexus.archiver.UnArchiver;
33  import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;
34  import org.junit.jupiter.api.Test;
35  import org.junit.jupiter.params.ParameterizedTest;
36  import org.junit.jupiter.params.provider.Arguments;
37  import org.junit.jupiter.params.provider.MethodSource;
38  
39  import static org.assertj.core.api.Assertions.assertThat;
40  import static org.junit.jupiter.api.Assertions.assertFalse;
41  import static org.junit.jupiter.api.Assertions.assertNotNull;
42  import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
43  import static org.junit.jupiter.api.Assertions.assertTrue;
44  
45  /**
46   * @author Dan T. Tran
47   */
48  class ArchiverManagerTest extends TestSupport {
49  
50      // list of items which support Archiver and UnArchiver
51      private static Stream<String> getArchiversAndUnArchiverForTests() {
52          return Stream.of(
53                  "bzip2",
54                  "ear",
55                  "gzip",
56                  "jar",
57                  "rar",
58                  "tar",
59                  "tar.bz2",
60                  "tar.gz",
61                  "tar.snappy",
62                  "tar.xz",
63                  "tar.zst",
64                  "tbz2",
65                  "tgz",
66                  "txz",
67                  "tzst",
68                  "war",
69                  "xz",
70                  "zip",
71                  "snappy",
72                  "zst");
73      }
74  
75      // list of items which support UnArchiver
76      private static Stream<String> getUnArchiversForTests() {
77          return Stream.concat(
78                  getArchiversAndUnArchiverForTests(),
79                  Stream.of(
80                          // only UnArchivers
81                          "car", "esb", "nar", "par", "sar", "swc"));
82      }
83  
84      // list of Archiver
85      private static Stream<String> getArchiversForTests() {
86          return Stream.concat(
87                  getArchiversAndUnArchiverForTests(),
88                  Stream.of(
89                          // only Archivers
90                          "dir", "mjar"));
91      }
92  
93      private static Stream<String> getResourceCollectionsForTests() {
94          return Stream.concat(
95                  getUnArchiversForTests(),
96                  Stream.of(
97                          "default", "files", /* defined in plexus-io */
98                          "gz", "bz2" /* additional alias only for it */));
99      }
100 
101     @Test
102     void testReuseArchiver() throws Exception {
103         ArchiverManager manager = lookup(ArchiverManager.class);
104 
105         Archiver archiver = manager.getArchiver("jar");
106         assertNotNull(archiver);
107 
108         archiver.addDirectory(new File(getBasedir()));
109 
110         Archiver newArchiver = manager.getArchiver("jar");
111         assertNotNull(newArchiver);
112         assertFalse(newArchiver.equals(archiver));
113 
114         assertTrue(!newArchiver.getResources().hasNext());
115     }
116 
117     @Test
118     void allArchiversShouldBeUnderTest() {
119         ArchiverManager manager = lookup(ArchiverManager.class);
120 
121         assertThat(manager.getAvailableArchivers())
122                 .containsExactlyInAnyOrderElementsOf(getArchiversForTests().collect(Collectors.toList()));
123     }
124 
125     @Test
126     void allUnArchiversShouldBeUnderTest() {
127         ArchiverManager manager = lookup(ArchiverManager.class);
128 
129         assertThat(manager.getAvailableUnArchivers())
130                 .containsExactlyInAnyOrderElementsOf(getUnArchiversForTests().collect(Collectors.toList()));
131     }
132 
133     @Test
134     void allResourceCollectionsShouldBeUnderTest() {
135         ArchiverManager manager = lookup(ArchiverManager.class);
136 
137         assertThat(manager.getAvailableResourceCollections())
138                 .containsExactlyInAnyOrderElementsOf(
139                         getResourceCollectionsForTests().collect(Collectors.toList()));
140     }
141 
142     @ParameterizedTest
143     @MethodSource("getArchiversForTests")
144     void testLookupArchiver(String archiveName) throws Exception {
145         ArchiverManager manager = lookup(ArchiverManager.class);
146         Archiver archiver = manager.getArchiver(archiveName);
147 
148         assertThat(archiver).isNotNull();
149     }
150 
151     @ParameterizedTest
152     @MethodSource("getUnArchiversForTests")
153     void testLookupUnArchiver(String archiveName) throws Exception {
154         ArchiverManager manager = lookup(ArchiverManager.class);
155         UnArchiver archiver = manager.getUnArchiver(archiveName);
156 
157         assertThat(archiver).isNotNull();
158     }
159 
160     @ParameterizedTest
161     @MethodSource("getResourceCollectionsForTests")
162     void testLookupResourceCollection(String resourceName) throws Exception {
163         ArchiverManager manager = lookup(ArchiverManager.class);
164         PlexusIoResourceCollection resourceCollection = manager.getResourceCollection(resourceName);
165 
166         assertThat(resourceCollection).isNotNull();
167     }
168 
169     @Test
170     void testLookupUnknownArchiver() {
171         ArchiverManager manager = lookup(ArchiverManager.class);
172 
173         assertThrowsExactly(NoSuchArchiverException.class, () -> manager.getArchiver("Unknown"));
174     }
175 
176     @Test
177     void testLookupUnknownUnArchiver() {
178         ArchiverManager manager = lookup(ArchiverManager.class);
179 
180         assertThrowsExactly(NoSuchArchiverException.class, () -> manager.getUnArchiver("Unknown"));
181     }
182 
183     @Test
184     void testLookupUnknownResourceCollection() {
185         ArchiverManager manager = lookup(ArchiverManager.class);
186 
187         assertThrowsExactly(NoSuchArchiverException.class, () -> manager.getResourceCollection("Unknown"));
188     }
189 
190     @ParameterizedTest
191     @MethodSource("getUnArchiversForTests")
192     void testLookupUnArchiverUsingFile(String archiveName) throws Exception {
193         ArchiverManager manager = lookup(ArchiverManager.class);
194 
195         UnArchiver archiver = manager.getUnArchiver(new File("test", "test." + archiveName));
196         assertThat(archiver).isNotNull();
197     }
198 
199     @ParameterizedTest
200     @MethodSource("getArchiversForTests")
201     void testLookupArchiverUsingFile(String archiveName) throws Exception {
202         ArchiverManager manager = lookup(ArchiverManager.class);
203 
204         Archiver archiver = manager.getArchiver(new File("test." + archiveName));
205         assertThat(archiver).isNotNull();
206     }
207 
208     private static Stream<Arguments> getUnsupportedFiles() {
209         return Stream.of(
210                 Arguments.of("", ""),
211                 Arguments.of("test", ""),
212                 Arguments.of("test.xxx", "xxx"),
213                 Arguments.of("test.tar.xxx", "tar.xxx"),
214                 Arguments.of("tar.gz.xxx", "xxx"));
215     }
216 
217     @ParameterizedTest
218     @MethodSource("getUnsupportedFiles")
219     void testUnsupportedLookupArchiverUsingFile(String fileName, String fileExtension) {
220         ArchiverManager manager = lookup(ArchiverManager.class);
221 
222         NoSuchArchiverException exception = assertThrowsExactly(
223                 NoSuchArchiverException.class, () -> manager.getArchiver(new File("test", fileName)));
224 
225         assertThat(exception.getArchiver()).isEqualTo(fileExtension);
226     }
227 
228     @ParameterizedTest
229     @MethodSource("getUnsupportedFiles")
230     void testUnsupportedLookupUnArchiverUsingFile(String fileName, String fileExtension) {
231         ArchiverManager manager = lookup(ArchiverManager.class);
232 
233         NoSuchArchiverException exception =
234                 assertThrowsExactly(NoSuchArchiverException.class, () -> manager.getUnArchiver(new File(fileName)));
235 
236         assertThat(exception.getArchiver()).isEqualTo(fileExtension);
237     }
238 
239     @ParameterizedTest
240     @MethodSource("getUnsupportedFiles")
241     void testUnsupportedLookupResourceCollectionUsingFile(String fileName, String fileExtension) {
242         ArchiverManager manager = lookup(ArchiverManager.class);
243 
244         NoSuchArchiverException exception = assertThrowsExactly(
245                 NoSuchArchiverException.class, () -> manager.getResourceCollection(new File(fileName)));
246 
247         assertThat(exception.getArchiver()).isEqualTo(fileExtension);
248     }
249 }