1 package org.apache.maven.toolchain;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.fail;
24 import static org.mockito.Matchers.anyString;
25 import static org.mockito.Mockito.mock;
26 import static org.mockito.Mockito.never;
27 import static org.mockito.Mockito.verify;
28 import static org.mockito.Mockito.when;
29
30 import java.util.ArrayList;
31 import java.util.HashMap;
32 import java.util.List;
33 import java.util.Map;
34
35 import org.apache.maven.execution.DefaultMavenExecutionRequest;
36 import org.apache.maven.execution.MavenExecutionRequest;
37 import org.apache.maven.execution.MavenSession;
38 import org.apache.maven.toolchain.model.ToolchainModel;
39 import org.codehaus.plexus.logging.Logger;
40 import org.junit.Before;
41 import org.junit.Test;
42 import org.mockito.InjectMocks;
43 import org.mockito.Mock;
44 import org.mockito.MockitoAnnotations;
45
46 public class DefaultToolchainManagerPrivateTest
47 {
48
49 @Mock
50 private Logger logger;
51
52 @InjectMocks
53 private DefaultToolchainManagerPrivate toolchainManager;
54
55 @Mock
56 private ToolchainFactory toolchainFactory_basicType;
57
58 @Mock
59 private ToolchainFactory toolchainFactory_rareType;
60
61 @Before
62 public void setUp()
63 {
64 toolchainManager = new DefaultToolchainManagerPrivate();
65
66 MockitoAnnotations.initMocks( this );
67
68 toolchainManager.factories = new HashMap<>();
69 toolchainManager.factories.put( "basic", toolchainFactory_basicType );
70 toolchainManager.factories.put( "rare", toolchainFactory_rareType );
71 }
72
73 @Test
74 public void testToolchainsForAvailableType()
75 throws Exception
76 {
77
78 MavenSession session = mock( MavenSession.class );
79 MavenExecutionRequest req = new DefaultMavenExecutionRequest();
80 when( session.getRequest() ).thenReturn( req );
81
82 ToolchainPrivate basicToolchain = mock( ToolchainPrivate.class );
83 when( toolchainFactory_basicType.createDefaultToolchain() ).thenReturn( basicToolchain );
84 ToolchainPrivate rareToolchain = mock( ToolchainPrivate.class );
85 when( toolchainFactory_rareType.createDefaultToolchain() ).thenReturn( rareToolchain );
86
87
88 ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "basic", session );
89
90
91 verify( logger, never() ).error( anyString() );
92 assertEquals( 1, toolchains.length );
93 }
94
95 @Test
96 public void testToolchainsForUnknownType()
97 throws Exception
98 {
99
100 MavenSession session = mock( MavenSession.class );
101 MavenExecutionRequest req = new DefaultMavenExecutionRequest();
102 when( session.getRequest() ).thenReturn( req );
103
104 ToolchainPrivate basicToolchain = mock( ToolchainPrivate.class );
105 when( toolchainFactory_basicType.createDefaultToolchain() ).thenReturn( basicToolchain );
106 ToolchainPrivate rareToolchain = mock( ToolchainPrivate.class );
107 when( toolchainFactory_rareType.createDefaultToolchain() ).thenReturn( rareToolchain );
108
109
110 ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "unknown", session );
111
112
113 verify( logger ).error( "Missing toolchain factory for type: unknown. Possibly caused by misconfigured project." );
114 assertEquals( 0, toolchains.length );
115 }
116
117 @Test
118 public void testToolchainsForConfiguredType()
119 throws Exception
120 {
121
122 MavenSession session = mock( MavenSession.class );
123 MavenExecutionRequest req = new DefaultMavenExecutionRequest();
124 when( session.getRequest() ).thenReturn( req );
125 Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>();
126 req.setToolchains( groupedToolchains );
127
128 List<ToolchainModel> basicToolchains = new ArrayList<>();
129 ToolchainModel basicToolchainModel = new ToolchainModel();
130 basicToolchainModel.setType( "basic" );
131 basicToolchains.add( basicToolchainModel );
132 basicToolchains.add( basicToolchainModel );
133 groupedToolchains.put( "basic", basicToolchains );
134
135 List<ToolchainModel> rareToolchains = new ArrayList<>();
136 ToolchainModel rareToolchainModel = new ToolchainModel();
137 rareToolchainModel.setType( "rare" );
138 rareToolchains.add( rareToolchainModel );
139 groupedToolchains.put( "rare", rareToolchains );
140
141
142 ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "basic", session );
143
144
145 verify( logger, never() ).error( anyString() );
146 assertEquals( 2, toolchains.length );
147 }
148
149 @SuppressWarnings( "unchecked" )
150 @Test( expected = MisconfiguredToolchainException.class )
151 public void testMisconfiguredToolchain()
152 throws Exception
153 {
154
155 MavenSession session = mock( MavenSession.class );
156 MavenExecutionRequest req = new DefaultMavenExecutionRequest();
157 when( session.getRequest() ).thenReturn( req );
158 when(toolchainFactory_basicType.createDefaultToolchain()).thenThrow( MisconfiguredToolchainException.class );
159
160
161 toolchainManager.getToolchainsForType( "basic", session );
162
163
164 fail( "Should exit with a MisconfiguredToolchainException" );
165 }
166 }