1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
47
48 class ArchiverManagerTest extends TestSupport {
49
50
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
76 private static Stream<String> getUnArchiversForTests() {
77 return Stream.concat(
78 getArchiversAndUnArchiverForTests(),
79 Stream.of(
80
81 "car", "esb", "nar", "par", "sar", "swc"));
82 }
83
84
85 private static Stream<String> getArchiversForTests() {
86 return Stream.concat(
87 getArchiversAndUnArchiverForTests(),
88 Stream.of(
89
90 "dir", "mjar"));
91 }
92
93 private static Stream<String> getResourceCollectionsForTests() {
94 return Stream.concat(
95 getUnArchiversForTests(),
96 Stream.of(
97 "default", "files",
98 "gz", "bz2" ));
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 }