public static TResult Query <TResult>(this IDispatcher dispatcher, QueryBase <TResult> message, Action <MessageExecuteSetting> configurationSetting) where TResult : class
{
var setting = new MessageExecuteSetting();
configurationSetting.Do(action => action(setting));
return(dispatcher.Query(message, setting));
}
public static void Push(this IDispatcher dispatcher, CommandBase message, Action <MessageExecuteSetting> configurationSetting)
{
var setting = new MessageExecuteSetting();
configurationSetting.Do(action => action(setting));
dispatcher.Push(message, setting);
}
public Lazy <IUnitOfWork> AddOrGet(MessageExecuteSetting setting, bool isFlush)
{
if (!ContainsKey(setting))
{
Add(setting, new Lazy <IUnitOfWork>(() =>
{
var unitOfWorkFactory = string.IsNullOrWhiteSpace(setting.DataBaseInstance)
? IoCFactory.Instance.TryResolve <IUnitOfWorkFactory>()
: IoCFactory.Instance.TryResolveByNamed <IUnitOfWorkFactory>(setting.DataBaseInstance);
var isoLevel = setting.IsolationLevel.GetValueOrDefault(isFlush ? IsolationLevel.ReadCommitted : IsolationLevel.ReadUncommitted);
return(unitOfWorkFactory.Create(isoLevel, isFlush, setting.Connection));
}, LazyThreadSafetyMode.None));
}
return(this[setting]);
}
public async Task <TResult> QueryAsync <TResult>(QueryBaseAsync <TResult> message, MessageExecuteSetting executeSetting = null)
{
return(await _dispatcherImplementation.QueryAsync(message, executeSetting));
}
public TResult Query <TResult>(QueryBase <TResult> message, MessageExecuteSetting executeSetting = null)
{
return(_dispatcherImplementation.Query(message, executeSetting));
}
public void ShouldBePush <TCommand>(Action <TCommand> action, MessageExecuteSetting executeSetting = null, int callCount = 1) where TCommand : CommandBase
{
this.dispatcher.ShouldBePush(action, executeSetting, callCount);
}
public MockController <TController> StubPushAsThrow <TCommand>(TCommand command, Exception exception, MessageExecuteSetting executeSetting = null) where TCommand : CommandBase
{
this.dispatcher.StubPushAsThrow(command, exception, executeSetting);
return(this);
}
public MockController <TController> StubQuery <TQuery, TResult>(TQuery query, TResult result, MessageExecuteSetting executeSetting = null) where TQuery : QueryBase <TResult> where TResult : class
{
this.dispatcher.StubQuery(query, result, executeSetting);
return(this);
}
public async Task <TResult> QueryAsync <TResult>(QueryBaseAsync <TResult> message, MessageExecuteSetting executeSetting = null)
{
await PushAsyncInternal(new CommandComposite(message, executeSetting));
return((TResult)message.Result);
}
public static void StubQuery <TQuery, TResult>(this Mock <IDispatcher> dispatcher, TQuery query, Action <ICompareFactoryDsl <TQuery, TQuery> > dsl, TResult result, MessageExecuteSetting executeSetting = null)
where TQuery : QueryBase <TResult>
{
dispatcher.Setup(r => r.Query(Pleasure.MockIt.IsStrong(query, dsl), Pleasure.MockIt.IsStrong(executeSetting)))
.Returns(result);
}
public static void Push(this IDispatcher dispatcher, CommandBase message, MessageExecuteSetting executeSetting = null)
{
dispatcher.Push(composite => composite.Quote(message, executeSetting));
}
public static void StubQuery <TQuery, TResult>(this Mock <IDispatcher> dispatcher, TQuery query, TResult result, MessageExecuteSetting executeSetting = null) where TQuery : QueryBase <TResult> where TResult : class
{
dispatcher
.Setup(r => r.Query(Pleasure.MockIt.IsStrong(query), Pleasure.MockIt.IsStrong(executeSetting)))
.Returns(result);
}
public static void StubPushAsThrow <TCommand>(this Mock <IDispatcher> dispatcher, TCommand command, Exception exception, MessageExecuteSetting executeSetting = null) where TCommand : CommandBase
{
Action <CommandComposite> verify = commandComposite =>
{
commandComposite.Parts.ShouldNotBeEmpty();
var part = commandComposite.Parts[0];
part.Message.ShouldEqualWeak(command);
part.Setting.ShouldEqualWeak(executeSetting ?? new MessageExecuteSetting());
};
dispatcher.Setup(r => r.Push(Pleasure.MockIt.Is(verify))).Throws(exception);
}
public static void ShouldBePush <TCommand>(this Mock <IDispatcher> dispatcher, Action <TCommand> verifyCommand, MessageExecuteSetting executeSetting = null, int callCount = 1) where TCommand : CommandBase
{
executeSetting = executeSetting ?? new MessageExecuteSetting();
Func <CommandComposite.MessageCompositePart, bool> predicate = part =>
{
try
{
verifyCommand((TCommand)part.Message);
part.Setting.ShouldEqualWeak(executeSetting);
return(true);
}
catch (Exception)
{
return(false);
}
};
if (callCount == 0)
{
dispatcher.Verify(r => r.Push(Pleasure.MockIt.Is <CommandComposite>(composite => composite.Parts.Any(predicate).ShouldBeTrue())), Times.Never());
}
else
{
dispatcher.Verify(r => r.Push(Pleasure.MockIt.Is <CommandComposite>(composite => composite.Parts.Count(predicate).ShouldEqual(callCount))));
}
}
public static void ShouldBePush <TCommand>(this Mock <IDispatcher> dispatcher, TCommand command, MessageExecuteSetting executeSetting = null, int callCount = 1) where TCommand : CommandBase
{
ShouldBePush <TCommand>(dispatcher, arg => arg.ShouldEqualWeak(command), executeSetting, callCount);
}
public static void StubPush <TCommand>(this Mock <IDispatcher> dispatcher, TCommand command, MessageExecuteSetting executeSetting = null, int callCount = 1) where TCommand : CommandBase
{
StubPush <TCommand>(dispatcher, arg => arg.ShouldEqualWeak(command, dsl => dsl.ForwardToValue(r => r.Setting, executeSetting ?? new MessageExecuteSetting())), callCount);
}
public static void StubPushAsThrow <TCommand>(this Mock <IDispatcher> dispatcher, TCommand command, Exception exception, MessageExecuteSetting executeSetting = null) where TCommand : CommandBase
{
Action <CommandComposite> verify = commandComposite =>
{
commandComposite.Parts.ShouldNotBeEmpty();
bool isAnySatisfied = commandComposite.Parts.Any(message =>
{
try
{
message.ShouldEqualWeak(command, dsl => dsl.ForwardToValue(r => r.Setting, executeSetting ?? new MessageExecuteSetting()));
return(true);
}
catch (SpecificationException)
{
return(false);
}
});
if (!isAnySatisfied)
{
throw new SpecificationException();
}
};
dispatcher.Setup(r => r.Push(Pleasure.MockIt.Is(verify))).Throws(exception);
}
/// <summary>
/// Mock Dispatcher.Push call
/// </summary>
/// <typeparam name="TCommand"></typeparam>
/// <param name="command"></param>
/// <param name="executeSetting"></param>
/// <param name="callCount"></param>
public void ShouldBePush <TCommand>(TCommand command, MessageExecuteSetting executeSetting = null, int callCount = 1) where TCommand : CommandBase
{
dispatcher.ShouldBePush(command, executeSetting, callCount);
}
public static void StubQueryAsThrow <TQuery, TResult>(this Mock <IDispatcher> dispatcher, TQuery query, Exception exception, MessageExecuteSetting executeSetting = null) where TQuery : QueryBase <TResult>
{
dispatcher
.Setup(r => r.Query(Pleasure.MockIt.IsStrong(query), Pleasure.MockIt.IsStrong(executeSetting)))
.Throws(exception);
}
public TResult Query <TResult>(QueryBase <TResult> message, MessageExecuteSetting executeSetting = null)
{
Push(new CommandComposite(message, executeSetting));
return((TResult)message.Result);
}
