com.helger.commons.mock

Class CommonsMock

java.lang.Object

com.helger.commons.mock.CommonsMock

public final class CommonsMock
extends Object

Mock objects by invoking their constructors with arbitrary objects. It separates into static mocking rules and "per instance" mocking rules. Static mocking rules apply to all instances of this class whereas "per instance" mocking rules apply only to this instance.

Author:

Philip Helger

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CommonsMock.Param This class represents a parameter description for a single mockable type.

Constructor Summary

Constructors

Constructor and Description
CommonsMock()

Method Summary

Modifier and Type	Method and Description
<T> T	mock(Class<T> aClass, Object... aParams) Create a mock instance of the passed class.
<T> ICommonsList<T>	mockMany(int nCount, Class<T> aClass, Object... aParams) Create a List of mocked objects.
<T> ICommonsSet<T>	mockSet(int nCount, Class<T> aClass, Object... aParams) Create a ICommonsSet of mocked objects.
<T> void	registerPerInstance(Class<T> aDstClass, CommonsMock.Param[] aParams, Function<IGetterDirectTrait[],T> aSupplier) Create a mock supplier with parameters.
<T> void	registerPerInstance(Class<T> aClass, Supplier<T> aSupplier) Register a simple supplier (=factory) to be invoked when an instance of the passed class is to be mocked.
void	registerPerInstance(com.helger.commons.mock.CommonsMock.MockSupplier aSupplier) Register an arbitrary MockSupplier.
<T> void	registerPerInstanceConstant(T aObject) Register a constant mock object.
static <T> void	registerStatic(Class<T> aDstClass, CommonsMock.Param[] aParams, Function<IGetterDirectTrait[],T> aSupplier) Create a mock supplier with parameters.
static <T> void	registerStatic(Class<T> aClass, Supplier<T> aSupplier) Register a simple supplier (=factory) to be invoked when an instance of the passed class is to be mocked.
static void	registerStatic(com.helger.commons.mock.CommonsMock.MockSupplier aSupplier) Register an arbitrary MockSupplier that is available across tests!
static <T> void	registerStaticConstant(T aObject) Register a constant mock object.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CommonsMock

public CommonsMock()

Method Detail

registerStaticConstant

public static final <T> void registerStaticConstant(@Nonnull
                                                    T aObject)

Register a constant mock object. That class will always be mocked with the specified instance.

Type Parameters:

T - The type to be mocked

Parameters:

aObject - The object to be used as a mock result. May not be null .

registerStatic

public static final <T> void registerStatic(@Nonnull
                                            Class<T> aClass,
                                            @Nonnull
                                            Supplier<T> aSupplier)

Register a simple supplier (=factory) to be invoked when an instance of the passed class is to be mocked. This method does not give you any possibility to provide parameters and so this works only if mock instance creation is fixed.

Type Parameters:

T - The type to be mocked

Parameters:

aClass - The class to be mocked. May not be null.

aSupplier - The supplier/factory to be invoked when to mock this class. May not be null.

registerStatic

public static final <T> void registerStatic(@Nonnull
                                            Class<T> aDstClass,
                                            @Nonnull
                                            CommonsMock.Param[] aParams,
                                            @Nonnull
                                            Function<IGetterDirectTrait[],T> aSupplier)

Create a mock supplier with parameters.

Type Parameters:

T - The type to be mocked

Parameters:

aDstClass - The destination class to be mocked. May not be null.

aParams - The parameter declarations to be used. May not be null.

aSupplier - The generic function to be invoked. Must take an array of IGetterDirectTrait and return an instance of the passed class.

registerStatic

public static final void registerStatic(@Nonnull
                                        com.helger.commons.mock.CommonsMock.MockSupplier aSupplier)

Register an arbitrary MockSupplier that is available across tests!

Parameters:

aSupplier - The supplier to be registered. May not be null.

registerPerInstanceConstant

public final <T> void registerPerInstanceConstant(@Nonnull
                                                  T aObject)

Register a constant mock object. That class will always be mocked with the specified instance.

Type Parameters:

T - The type to be mocked

Parameters:

aObject - The object to be used as a mock result. May not be null .

registerPerInstance

public final <T> void registerPerInstance(@Nonnull
                                          Class<T> aClass,
                                          @Nonnull
                                          Supplier<T> aSupplier)

Register a simple supplier (=factory) to be invoked when an instance of the passed class is to be mocked. This method does not give you any possibility to provide parameters and so this works only if mock instance creation is fixed.

Type Parameters:

T - The type to be mocked

Parameters:

aClass - The class to be mocked. May not be null.

aSupplier - The supplier/factory to be invoked when to mock this class. May not be null.

registerPerInstance

public final <T> void registerPerInstance(@Nonnull
                                          Class<T> aDstClass,
                                          @Nonnull
                                          CommonsMock.Param[] aParams,
                                          @Nonnull
                                          Function<IGetterDirectTrait[],T> aSupplier)

Create a mock supplier with parameters.

Type Parameters:

T - The type to be mocked

Parameters:

aDstClass - The destination class to be mocked. May not be null.

aParams - The parameter declarations to be used. May not be null.

aSupplier - The generic function to be invoked. Must take an array of IGetterDirectTrait and return an instance of the passed class.

registerPerInstance

public final void registerPerInstance(@Nonnull
                                      com.helger.commons.mock.CommonsMock.MockSupplier aSupplier)

Register an arbitrary MockSupplier.

Parameters:

aSupplier - The supplier to be registered. May not be null.

mock

@Nonnull
public <T> T mock(@Nonnull
                            Class<T> aClass,
                            @Nullable
                            Object... aParams)

Create a mock instance of the passed class.

Type Parameters:

T - The type to be mocked

Parameters:

aClass - The class to be mocked. May not be null.

aParams - An optional array of parameters to be passed to the mocking supplier. May be null or empty.

Returns:

The mocked object. Never null.

Throws:

IllegalStateException - If an exception occurred during the mock instance creation.

mockMany

@Nonnull
 @ReturnsMutableCopy
public <T> ICommonsList<T> mockMany(@Nonnegative
                                                                    int nCount,
                                                                    @Nonnull
                                                                    Class<T> aClass,
                                                                    @Nullable
                                                                    Object... aParams)

Create a List of mocked objects.

Type Parameters:

T - The type to be mocked

Parameters:

nCount - Number of objects to be mocked. Must be ≥ 0.

aClass - The class to be mocked.

aParams - An optional array of parameters to be passed to the mocking supplier for each object to be mocked. May be null or empty.

Returns:

The list with nCount entries.

mockSet

@Nonnull
 @ReturnsMutableCopy
public <T> ICommonsSet<T> mockSet(@Nonnegative
                                                                  int nCount,
                                                                  @Nonnull
                                                                  Class<T> aClass,
                                                                  @Nullable
                                                                  Object... aParams)

Create a ICommonsSet of mocked objects.

Type Parameters:

T - The type to be mocked

Parameters:

nCount - Number of objects to be mocked. Must be ≥ 0.

aClass - The class to be mocked.

aParams - An optional array of parameters to be passed to the mocking supplier for each object to be mocked. May be null or empty.

Returns:

The set with nCount entries.