1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.di;
20
21 import javax.inject.Named;
22 import javax.inject.Singleton;
23
24 import java.nio.file.Path;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.Optional;
28
29 import com.google.inject.AbstractModule;
30 import com.google.inject.Binding;
31 import com.google.inject.Injector;
32 import com.google.inject.TypeLiteral;
33 import org.apache.maven.api.model.Model;
34 import org.apache.maven.api.services.Source;
35 import org.apache.maven.api.spi.ModelParser;
36 import org.apache.maven.api.spi.ModelParserException;
37 import org.apache.maven.internal.impl.SisuDiBridgeModule;
38 import org.codehaus.plexus.DefaultContainerConfiguration;
39 import org.codehaus.plexus.DefaultPlexusContainer;
40 import org.codehaus.plexus.PlexusContainer;
41 import org.junit.jupiter.api.BeforeEach;
42 import org.junit.jupiter.api.Nested;
43 import org.junit.jupiter.api.Test;
44 import org.junit.jupiter.api.condition.EnabledIf;
45
46 import static org.junit.jupiter.api.Assertions.assertEquals;
47 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
48 import static org.junit.jupiter.api.Assertions.assertNotNull;
49
50 public class DiTest {
51
52
53 static boolean testShouldNotHaveDuplicates() {
54 return true;
55 }
56
57 @Nested
58 class DiTest1 {
59
60 PlexusContainer container;
61
62 @BeforeEach
63 void setup() throws Exception {
64 container = new DefaultPlexusContainer(
65 new DefaultContainerConfiguration(),
66 new AbstractModule() {
67 @Override
68 protected void configure() {
69 bind(ModelParser.class).to(TestModelParser.class);
70 }
71 },
72 new SisuDiBridgeModule(false));
73 }
74
75 @Test
76 void testPlexus() throws Exception {
77 List<ModelParser> parsers = container.lookupList(ModelParser.class);
78 assertNotNull(parsers);
79 assertEquals(1, parsers.size());
80 Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);
81 assertNotNull(parsersMap);
82 assertEquals(1, parsersMap.size());
83 }
84
85 @Test
86 void testGuice() throws Exception {
87 List<Binding<ModelParser>> parsers =
88 container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
89 assertNotNull(parsers);
90 assertEquals(1, parsers.size());
91 }
92
93 @Test
94 void testDI() throws Exception {
95 DiInjected diInjected = new DiInjected();
96 container.lookup(org.apache.maven.di.Injector.class).injectInstance(diInjected);
97 assertNotNull(diInjected.parser);
98 assertNotNull(diInjected.parsers);
99 assertEquals(1, diInjected.parsers.size());
100 assertNotNull(diInjected.parsersMap);
101 assertEquals(1, diInjected.parsersMap.size());
102 }
103
104 static class DiInjected {
105 @org.apache.maven.api.di.Inject
106 ModelParser parser;
107
108 @org.apache.maven.api.di.Inject
109 List<ModelParser> parsers;
110
111 @org.apache.maven.api.di.Inject
112 Map<String, ModelParser> parsersMap;
113 }
114
115 @Named
116 @Singleton
117 static class TestModelParser implements ModelParser {
118 @Override
119 public Optional<Source> locate(Path dir) {
120 return Optional.empty();
121 }
122
123 @Override
124 public Model parse(Source source, Map<String, ?> options) throws ModelParserException {
125 return null;
126 }
127 }
128 }
129
130 @Nested
131 class DiTest2 {
132
133 PlexusContainer container;
134
135 @BeforeEach
136 void setup() throws Exception {
137 container = new DefaultPlexusContainer(new DefaultContainerConfiguration(), new SisuDiBridgeModule(false) {
138 @Override
139 protected void configure() {
140 super.configure();
141 injector.bindImplicit(TestModelParser.class);
142 }
143 });
144 }
145
146 @Test
147 void testPlexus() throws Exception {
148 List<ModelParser> parsers = container.lookupList(ModelParser.class);
149 assertNotNull(parsers);
150 assertEquals(1, parsers.size());
151 Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);
152 assertNotNull(parsersMap);
153 assertEquals(1, parsersMap.size());
154 }
155
156 @Test
157 void testGuice() throws Exception {
158 List<Binding<ModelParser>> parsers2 =
159 container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
160 assertNotNull(parsers2);
161 assertEquals(1, parsers2.size());
162 }
163
164 @Test
165 @EnabledIf("org.apache.maven.di.DiTest#testShouldNotHaveDuplicates")
166 void testDI() throws Exception {
167 DiInjected diInjected = new DiInjected();
168 container.lookup(org.apache.maven.di.Injector.class).injectInstance(diInjected);
169 assertNotNull(diInjected.parser);
170 assertNotNull(diInjected.parsers);
171 assertEquals(1, diInjected.parsers.size());
172 assertNotNull(diInjected.parsersMap);
173 assertEquals(1, diInjected.parsersMap.size());
174 }
175
176 static class DiInjected {
177 @org.apache.maven.api.di.Inject
178 ModelParser parser;
179
180 @org.apache.maven.api.di.Inject
181 List<ModelParser> parsers;
182
183 @org.apache.maven.api.di.Inject
184 Map<String, ModelParser> parsersMap;
185 }
186
187 @org.apache.maven.api.di.Named
188 @org.apache.maven.api.di.Singleton
189 static class TestModelParser implements ModelParser {
190 @Override
191 public Optional<Source> locate(Path dir) {
192 return Optional.empty();
193 }
194
195 @Override
196 public Model parse(Source source, Map<String, ?> options) throws ModelParserException {
197 return null;
198 }
199 }
200 }
201
202 @Nested
203 class DiTest3 {
204
205 PlexusContainer container;
206
207 @BeforeEach
208 void setup() throws Exception {
209 container = new DefaultPlexusContainer(new DefaultContainerConfiguration(), new SisuDiBridgeModule(false) {
210 @Override
211 protected void configure() {
212 super.configure();
213 injector.bindImplicit(TestModelParser.class);
214 }
215 });
216 }
217
218 @Test
219 void testPlexus() throws Exception {
220 List<ModelParser> parsers = container.lookupList(ModelParser.class);
221 assertNotNull(parsers);
222 assertEquals(1, parsers.size());
223 Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);
224 assertNotNull(parsersMap);
225 assertEquals(1, parsersMap.size());
226 }
227
228 @Test
229 void testGuice() throws Exception {
230 List<Binding<ModelParser>> parsers =
231 container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
232 assertNotNull(parsers);
233 assertEquals(1, parsers.size());
234 }
235
236 @Test
237 @EnabledIf("org.apache.maven.di.DiTest#testShouldNotHaveDuplicates")
238 void testDI() throws Exception {
239 DiInjected diInjected = new DiInjected();
240 container.lookup(org.apache.maven.di.Injector.class).injectInstance(diInjected);
241 assertNotNull(diInjected.parser);
242 assertNotNull(diInjected.parsers);
243 assertEquals(1, diInjected.parsers.size());
244 assertNotNull(diInjected.parsersMap);
245 assertEquals(1, diInjected.parsersMap.size());
246 }
247
248 static class DiInjected {
249 @org.apache.maven.api.di.Inject
250 ModelParser parser;
251
252 @org.apache.maven.api.di.Inject
253 List<ModelParser> parsers;
254
255 @org.apache.maven.api.di.Inject
256 Map<String, ModelParser> parsersMap;
257 }
258
259 @org.apache.maven.api.di.Named
260 static class TestModelParser implements ModelParser {
261 @Override
262 public Optional<Source> locate(Path dir) {
263 return Optional.empty();
264 }
265
266 @Override
267 public Model parse(Source source, Map<String, ?> options) throws ModelParserException {
268 return null;
269 }
270 }
271 }
272
273 @Nested
274 class DiTest4 {
275
276 PlexusContainer container;
277
278 @BeforeEach
279 void setup() throws Exception {
280 container = new DefaultPlexusContainer(
281 new DefaultContainerConfiguration(),
282 new AbstractModule() {
283 @Override
284 protected void configure() {
285 bind(ModelParser.class).to(DiTest4.TestModelParserSisu.class);
286 }
287 },
288 new SisuDiBridgeModule(false) {
289 @Override
290 protected void configure() {
291 super.configure();
292 injector.bindImplicit(TestModelParserDi.class);
293 }
294 });
295 }
296
297 @Test
298 void testPlexus() throws Exception {
299 List<ModelParser> parsers = container.lookupList(ModelParser.class);
300 assertNotNull(parsers);
301 assertEquals(1, parsers.size());
302 Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);
303 assertNotNull(parsersMap);
304 assertEquals(1, parsersMap.size());
305 }
306
307 @Test
308 void testGuice() throws Exception {
309 List<Binding<ModelParser>> parsers =
310 container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
311 assertNotNull(parsers);
312 assertEquals(1, parsers.size());
313 }
314
315 @Test
316 void testDI() throws Exception {
317 DiInjected diInjected = new DiInjected();
318 container.lookup(org.apache.maven.di.Injector.class).injectInstance(diInjected);
319 assertNotNull(diInjected.parser);
320 assertInstanceOf(TestModelParserSisu.class, diInjected.parser);
321 assertNotNull(diInjected.parsers);
322 assertEquals(2, diInjected.parsers.size());
323 assertNotNull(diInjected.parsersMap);
324 assertEquals(2, diInjected.parsersMap.size());
325 }
326
327 static class DiInjected {
328 @org.apache.maven.api.di.Inject
329 ModelParser parser;
330
331 @org.apache.maven.api.di.Inject
332 List<ModelParser> parsers;
333
334 @org.apache.maven.api.di.Inject
335 Map<String, ModelParser> parsersMap;
336 }
337
338 @javax.inject.Named("sisu")
339 @org.eclipse.sisu.Priority(100)
340 static class TestModelParserSisu implements ModelParser {
341 @Override
342 public Optional<Source> locate(Path dir) {
343 return Optional.empty();
344 }
345
346 @Override
347 public Model parse(Source source, Map<String, ?> options) throws ModelParserException {
348 return null;
349 }
350 }
351
352
353 static class TestModelParserDi implements ModelParser {
354 @Override
355 public Optional<Source> locate(Path dir) {
356 return Optional.empty();
357 }
358
359 @Override
360 public Model parse(Source source, Map<String, ?> options) throws ModelParserException {
361 return null;
362 }
363 }
364 }
365 }