1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.surefire.providerapi;
20
21 import java.io.IOException;
22 import java.util.Collections;
23 import java.util.HashSet;
24 import java.util.List;
25
26 import org.apache.maven.surefire.api.provider.SurefireProvider;
27 import org.codehaus.plexus.logging.Logger;
28 import org.junit.Test;
29 import org.junit.runner.RunWith;
30 import org.mockito.InjectMocks;
31 import org.mockito.Mock;
32 import org.mockito.junit.MockitoJUnitRunner;
33
34 import static java.util.Arrays.asList;
35 import static org.assertj.core.api.Assertions.assertThat;
36 import static org.mockito.ArgumentMatchers.any;
37 import static org.mockito.ArgumentMatchers.anyString;
38 import static org.mockito.ArgumentMatchers.eq;
39 import static org.mockito.Mockito.mock;
40 import static org.mockito.Mockito.never;
41 import static org.mockito.Mockito.times;
42 import static org.mockito.Mockito.verify;
43 import static org.mockito.Mockito.verifyNoMoreInteractions;
44 import static org.mockito.Mockito.when;
45
46
47
48
49
50
51 @RunWith(MockitoJUnitRunner.class)
52 public class ProviderDetectorTest {
53
54 @Mock
55 private ServiceLoader serviceLoader;
56
57 @Mock
58 private Logger logger;
59
60 @InjectMocks
61 private ProviderDetector providerDetector;
62
63 @Test
64 public void emptyProviderList() throws Exception {
65
66 ProviderInfo providerInfo1 = mock(ProviderInfo.class);
67 ProviderInfo providerInfo2 = mock(ProviderInfo.class);
68
69
70 when(serviceLoader.lookup(eq(SurefireProvider.class), any(ClassLoader.class)))
71 .thenReturn(Collections.<String>emptySet());
72
73
74 when(providerInfo1.isApplicable()).thenReturn(false);
75 when(providerInfo2.isApplicable()).thenReturn(false);
76
77
78 List<ProviderInfo> providerInfoList = providerDetector.resolve(null, providerInfo1, providerInfo2);
79
80
81 assertThat(providerInfoList).isEmpty();
82
83 verify(serviceLoader).lookup(eq(SurefireProvider.class), any(ClassLoader.class));
84
85 verify(providerInfo1).isApplicable();
86 verify(providerInfo2).isApplicable();
87
88 verifyNoMoreInteractions(logger, serviceLoader, providerInfo1, providerInfo2);
89 }
90
91 @Test
92 public void onlyFirstAutomaticallyProviderIsReturned() throws Exception {
93
94 ProviderInfo providerInfo1 = mock(ProviderInfo.class);
95 ProviderInfo providerInfo2 = mock(ProviderInfo.class);
96
97
98 when(serviceLoader.lookup(eq(SurefireProvider.class), any(ClassLoader.class)))
99 .thenReturn(Collections.<String>emptySet());
100
101
102 when(providerInfo1.isApplicable()).thenReturn(true);
103
104
105 List<ProviderInfo> providerInfoList = providerDetector.resolve(null, providerInfo1, providerInfo2);
106
107
108 assertThat(providerInfoList).containsExactly(providerInfo1);
109
110 verify(serviceLoader).lookup(eq(SurefireProvider.class), any(ClassLoader.class));
111
112 verify(providerInfo1).isApplicable();
113 verify(providerInfo1).getProviderName();
114
115
116 verify(providerInfo2, never()).isApplicable();
117
118 verify(logger).info(anyString());
119
120 verifyNoMoreInteractions(logger, serviceLoader, providerInfo1, providerInfo2);
121 }
122
123 @Test
124 public void allManuallyConfiguredProviderAreReturned() throws IOException {
125
126 ProviderInfo providerInfo1 = mock(ProviderInfo.class);
127 ProviderInfo providerInfo2 = mock(ProviderInfo.class);
128
129
130 when(serviceLoader.lookup(eq(SurefireProvider.class), any(ClassLoader.class)))
131 .thenReturn(new HashSet<>(asList("provider1", "provider2")));
132
133 when(providerInfo1.getProviderName()).thenReturn("provider1");
134 when(providerInfo2.getProviderName()).thenReturn("provider2");
135
136
137 List<ProviderInfo> providerInfoList = providerDetector.resolve(null, providerInfo1, providerInfo2);
138
139
140 assertThat(providerInfoList).containsExactly(providerInfo1, providerInfo2);
141
142 verify(serviceLoader).lookup(eq(SurefireProvider.class), any(ClassLoader.class));
143
144 verify(providerInfo1, times(3)).getProviderName();
145 verify(providerInfo2, times(2)).getProviderName();
146
147
148 verify(providerInfo1, never()).isApplicable();
149 verify(providerInfo1, never()).isApplicable();
150
151 verify(logger, times(2)).info(anyString());
152
153 verifyNoMoreInteractions(logger, serviceLoader, providerInfo1, providerInfo2);
154 }
155
156 @Test
157 public void dynamicallyProviderAreReturned() throws IOException {
158
159 ProviderInfo providerInfo1 = mock(ProviderInfo.class);
160 ProviderInfo providerInfo2 = mock(ProviderInfo.class);
161 ProviderInfo dynProviderInfo = mock(ProviderInfo.class);
162
163 ConfigurableProviderInfo dynamicProvider = mock(ConfigurableProviderInfo.class);
164
165
166 when(serviceLoader.lookup(eq(SurefireProvider.class), any(ClassLoader.class)))
167 .thenReturn(new HashSet<>(asList("unKnown", "provider2")));
168
169 when(dynamicProvider.instantiate(anyString())).thenReturn(dynProviderInfo);
170
171 when(providerInfo1.getProviderName()).thenReturn("provider1");
172 when(providerInfo2.getProviderName()).thenReturn("provider2");
173
174
175 List<ProviderInfo> providerInfoList = providerDetector.resolve(dynamicProvider, providerInfo1, providerInfo2);
176
177
178 assertThat(providerInfoList).containsExactly(dynProviderInfo, providerInfo2);
179
180 verify(serviceLoader).lookup(eq(SurefireProvider.class), any(ClassLoader.class));
181
182 verify(dynamicProvider).instantiate("unKnown");
183
184 verify(providerInfo1, times(2)).getProviderName();
185 verify(providerInfo2, times(3)).getProviderName();
186
187
188 verify(providerInfo1, never()).isApplicable();
189 verify(dynamicProvider, never()).isApplicable();
190
191 verify(logger, times(2)).info(anyString());
192
193 verifyNoMoreInteractions(logger, serviceLoader, dynamicProvider, providerInfo1, providerInfo2);
194 }
195 }