public void A_TestInit()
{
// Create instance of Moqqer
_moq = new Moqqer();
// Create an instance of SomeClass injecting mocks into constructor
}
public static void Add <T>(this Moqqer moq, params T[] items)
{
foreach (var item in items)
{
moq.Add(item);
}
}
public static void AddItems <T>(this Moqqer moq, IEnumerable <T> items)
{
foreach (var item in items)
{
moq.Add(item);
}
}
public void A_TestSetup()
{
_moq = new Moqqer();
_comparer = IoC.Container.GetInstance <DataComparer>();
_left = Tables.Default;
_right = Tables.Default;
}
public override object CreateGeneric <T>(Moqqer moq, Type type, Type openType)
{
var list = moq.List <T>();
return(moq.UseMoqqerEnumerableQuery
? list.AsMoqqerQueryable()
: list.AsQueryable());
}
public override object CreateGeneric <T>(Moqqer moq, Type type, Type openType)
{
var list = moq.List <T>();
var collection = new ObservableCollection <T>(list);
collection.SetItems(list);
return(collection);
}
public override object CreateGeneric <T>(Moqqer moq, Type type, Type openType)
{
var instance = moq.GetInstance(typeof(T));
// ReSharper disable once MergeConditionalExpression
var result = instance is T
? (T)instance
: default(T);
return(TaskHelper.FromResult(result));
}
public void DoWork_CallsRepositoryGetData()
{
// 1 - First create an instance of Moqqer which will
// act as a container for Mocks and Objects.
_moq = new Moqqer();
// 2 - Get Moqqer to create an instance of some class you want to test.
// It will auto inject mocks in the its constructor.
_subject = _moq.Create <SomeClass>();
// 3 - Call the mothod you want to test on SomeClass
_subject.CallA(); // Calls private field IDependencyA.Call()
// 4 - Verify a mock that was auto injected was called.
_moq.Of <IDepencyA>()
.Verify(x => x.Call(), Times.Once);
// Alternatively use the Verify extension method
_moq.Verify <IDepencyA>(x => x.Call())
.Once();
// 5 - Test and Refactor to your hearts content
// without worrying about changing the constructor calls!
}
public object Create(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
var meth = CreateGenericMethodInfo.MakeGenericMethod(genericArguments);
return(meth.Invoke(this, new object[] { moq, type, openType }));
}
public static MoqFluentVerifyBuilder <T> .IHasVerifyAction Verify <T>
(this Moqqer moq, Expression <Action <T> > action)
where T : class
{
return(new MoqFluentVerifyBuilder <T>(moq.Of <T>(), action));
}
public bool CanHandle(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
return(typeof(List <>)
.IsOpenGenericAssignableToOpenGenericType(openType));
}
private bool AreMockable(Moqqer moq, Type type)
{
return(moq.CanGetDefaultOrMock(type));
}
public static void Add <T>(this Moqqer moq, T item)
{
moq.List <T>().Add(item);
}
internal object GetOrCreateList(Moqqer moq, Type[] genericArguments)
{
var listType = typeof(List <>).MakeGenericType(genericArguments);
return(moq.GetOrCreateObject(listType));
}
public object Create(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
return(GetOrCreateList(moq, genericArguments));
}
public override bool CanHandle(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
return(openType == typeof(Task <>) && genericArguments.All(x => AreMockable(moq, x)));
}
public void A_TestSetup()
{
_moq = new Moqqer();
_root = _moq.Create <Root>();
}
public abstract bool CanHandle(Moqqer moq, Type type, Type openType, Type[] genericArguments);
public override bool CanHandle(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
return(openType == typeof(IQueryable <>));
}
public override bool CanHandle(Moqqer moq, Type type, Type openType, Type[] genericArguments)
{
return(openType == typeof(ObservableCollection <>));
}
public void A_TestSetup()
{
_moq = new Moqqer();
}
public abstract object CreateGeneric <T>(Moqqer moq, Type type, Type openType);
