package org.apache.onami.test;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import static com.google.common.base.Preconditions.checkState;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.onami.test.annotation.Mock;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.google.inject.AbstractModule;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Names;
/**
* <p>
* This class creates the binding for all mock objects found.
* </p>
* <p>
* Method {@link GuiceMockModule#configure()} creates a binding for each {@link Mock} annotation found. The binding will
* be created <b>if and only if</b> there is no types conflict between {@link Mock} caught.
* <p>
* <p>
* <b>A type conflict</b> is detected if two or more field are annotated with the same {@link Mock} and no different
* {@link Mock#annotatedWith} parameter are specified, or two o more equals {@link Mock#annotatedWith} parameter are
* specified for the same type field.
* </p>
* <p>
* If a conflict is detected the binding will not create for the conflicted type, moreover the field will be injected
* into the test class.
* </p>
*/
public class GuiceMockModule
extends AbstractModule
{
private static final Logger LOGGER = Logger.getLogger( GuiceMockModule.class.getName() );
final Map<Field, Object> mockedFields;
/**
* Costructor.
*
* @param mockedFields the map of mock fileds.
*/
public GuiceMockModule( final Map<Field, Object> mockedFields )
{
this.mockedFields = mockedFields;
}
@SuppressWarnings( "unchecked" )
@Override
protected void configure()
{
final Multimap<Type, Field> fieldsByType = HashMultimap.create();
for ( final Entry<Field, Object> entry : this.mockedFields.entrySet() )
{
fieldsByType.put( entry.getKey().getGenericType(), entry.getKey() );
}
for ( final Type type : fieldsByType.keySet() )
{
final Collection<Field> fields = fieldsByType.get( type );
boolean isTypeConflicts = false;
if ( fields.size() != 1 )
{
isTypeConflicts = checkTypeConflict( fields );
}
checkState( !isTypeConflicts, " Found multiple annotation @%s for type: %s; binding skipped!.",
Mock.class.getSimpleName(), type );
for ( final Field field : fields )
{
final TypeLiteral literal = TypeLiteral.get( type );
final Mock annoBy = field.getAnnotation( Mock.class );
final Object mock = this.mockedFields.get( field );
if ( annoBy.annotatedWith() != Mock.NoAnnotation.class )
{
bind( literal ).annotatedWith( annoBy.annotatedWith() ).toInstance( mock );
}
else if ( !"".equals( annoBy.namedWith() ) )
{
bind( literal ).annotatedWith( Names.named( annoBy.namedWith() ) ).toInstance( mock );
}
else
{
bind( literal ).toInstance( mock );
}
if ( LOGGER.isLoggable( Level.FINER ) )
{
LOGGER.finer( " Created binding for: " + type + " " + annoBy );
}
}
}
}
/**
* @param fields
* @return
*/
private boolean checkTypeConflict( Collection<Field> fields )
{
final List<Class<?>> listAnnotatedType = new ArrayList<Class<?>>();
final List<String> listNamedType = new ArrayList<String>();
int numOfSimpleType = 0;
for ( Field field : fields )
{
final Mock annoBy = field.getAnnotation( Mock.class );
if ( annoBy.annotatedWith() == Mock.NoAnnotation.class && "".equals( annoBy.namedWith() ) )
{
numOfSimpleType++;
}
if ( numOfSimpleType > 1 )
{
LOGGER.finer( "Found multiple simple type" );
return true;
}
if ( annoBy.annotatedWith() != Mock.NoAnnotation.class )
{
if ( !listAnnotatedType.contains( annoBy.annotatedWith() ) )
{
listAnnotatedType.add( annoBy.annotatedWith() );
}
else
{
// found two fields with same annotation
LOGGER.finer( "Found multiple annotatedBy type" );
return true;
}
}
if ( !"".equals( annoBy.namedWith() ) )
{
if ( !listNamedType.contains( annoBy.namedWith() ) )
{
listNamedType.add( annoBy.namedWith() );
}
else
{
// found two fields with same named annotation
LOGGER.finer( "Found multiple namedWith type" );
return true;
}
}
}
return false;
}
}