001package org.apache.maven.toolchain;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 *
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import static org.junit.Assert.assertEquals;
023import static org.junit.Assert.fail;
024import static org.mockito.Matchers.anyString;
025import static org.mockito.Mockito.mock;
026import static org.mockito.Mockito.never;
027import static org.mockito.Mockito.verify;
028import static org.mockito.Mockito.when;
029
030import java.util.ArrayList;
031import java.util.HashMap;
032import java.util.List;
033import java.util.Map;
034
035import org.apache.maven.execution.DefaultMavenExecutionRequest;
036import org.apache.maven.execution.MavenExecutionRequest;
037import org.apache.maven.execution.MavenSession;
038import org.apache.maven.toolchain.model.ToolchainModel;
039import org.codehaus.plexus.logging.Logger;
040import org.junit.Before;
041import org.junit.Test;
042import org.mockito.InjectMocks;
043import org.mockito.Mock;
044import org.mockito.MockitoAnnotations;
045
046public class DefaultToolchainManagerPrivateTest
047{
048    // Mocks to inject into toolchainManager
049    @Mock
050    private Logger logger;
051
052    @InjectMocks
053    private DefaultToolchainManagerPrivate toolchainManager;
054
055    @Mock
056    private ToolchainFactory toolchainFactory_basicType;
057    
058    @Mock
059    private ToolchainFactory toolchainFactory_rareType;
060
061    @Before
062    public void setUp()
063    {
064        toolchainManager = new DefaultToolchainManagerPrivate();
065
066        MockitoAnnotations.initMocks( this );
067
068        toolchainManager.factories = new HashMap<String, ToolchainFactory>();
069        toolchainManager.factories.put( "basic", toolchainFactory_basicType );
070        toolchainManager.factories.put( "rare", toolchainFactory_rareType );
071    }
072
073    @Test
074    public void testToolchainsForAvailableType()
075        throws Exception
076    {
077        // prepare
078        MavenSession session = mock( MavenSession.class );
079        MavenExecutionRequest req = new DefaultMavenExecutionRequest();
080        when( session.getRequest() ).thenReturn( req );
081
082        ToolchainPrivate basicToolchain = mock( ToolchainPrivate.class );
083        when( toolchainFactory_basicType.createDefaultToolchain() ).thenReturn( basicToolchain );
084        ToolchainPrivate rareToolchain = mock( ToolchainPrivate.class );
085        when( toolchainFactory_rareType.createDefaultToolchain() ).thenReturn( rareToolchain );
086
087        // execute
088        ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "basic", session );
089
090        // verify
091        verify( logger, never() ).error( anyString() );
092        assertEquals( 1, toolchains.length );
093    }
094
095    @Test
096    public void testToolchainsForUnknownType()
097        throws Exception
098    {
099        // prepare
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        // execute
110        ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "unknown", session );
111
112        // verify
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        // prepare
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<String, List<ToolchainModel>>();
126        req.setToolchains( groupedToolchains );
127
128        List<ToolchainModel> basicToolchains = new ArrayList<ToolchainModel>();
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<ToolchainModel>();
136        ToolchainModel rareToolchainModel = new ToolchainModel();
137        rareToolchainModel.setType( "rare" );
138        rareToolchains.add( rareToolchainModel );
139        groupedToolchains.put( "rare", rareToolchains );
140
141        // execute
142        ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType( "basic", session );
143
144        // verify
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        // prepare
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        // execute
161        toolchainManager.getToolchainsForType( "basic", session );
162        
163        // verify
164        fail( "Should exit with a MisconfiguredToolchainException" );
165    }
166}