public InsertComponent(IOptions <EntityMapperOptions> options, ResultExecutor resultExecutor)
{
Check.IfNullOrZero(options);
_resultExecutor = resultExecutor;
_options = options.Value;
}
public async Task CanExecuteInheritedResultAsync()
{
var type = typeof(ResultExecutorClassTest);
var method = type.GetMethod(nameof(ResultExecutorClassTest.TestMethodInheritedResult));
await using var context = new CommandContext();
var moduleBuilderMock = new Mock <IModuleBuilder>();
moduleBuilderMock.SetupGet(a => a.Type).Returns(type);
var commandBuilderMock = new Mock <ICommandBuilder>();
commandBuilderMock.SetupGet(a => a.IsAsync).Returns(false);
commandBuilderMock.SetupGet(a => a.MethodInfo).Returns(method);
var moduleBuilder = moduleBuilderMock.Object;
var commandBuilder = commandBuilderMock.Object;
var executor = ResultExecutor.Create(moduleBuilder, commandBuilder);
var module = new ResultExecutorClassTest();
(module as IModuleBase).SetContext(context);
var result = await executor.ExecuteAsync(module, new object[0]);
Assert.NotNull(result);
Assert.True(result.Success);
Assert.IsType <SuccessObjectResult>(result);
Assert.Equal(ResultExecutorClassTest.LogValue, (result as SuccessObjectResult).Value);
}
public void ExecuteThrowsExceptionWhenResponseStartedTest()
{
var mvcOptions = new MvcOptions();
var options = Substitute.For <IOptions <MvcOptions> >();
var writerFactory = Substitute.For <IHttpResponseStreamWriterFactory>();
var loggerFactory = Substitute.For <ILoggerFactory>();
options.Value.Returns(mvcOptions);
var formatSelector = new DefaultOutputFormatterSelector(options, loggerFactory);
var executor = new ObjectResultExecutor(formatSelector, writerFactory, loggerFactory);
var result = new ObjectResult(Guid.NewGuid().ToString());
var context = Substitute.For <HttpContext>();
var response = Substitute.For <HttpResponse>();
response.HasStarted.Returns(true);
context.Response.Returns(response);
var sut = new ResultExecutor(executor);
Func <Task> action = async() => await sut.Execute(context, result).ConfigureAwait(false);
action.Should().Throw <InvalidOperationException>();
}
public SelectComponent(IOptions <EntityMapperOptions> options, ResultExecutor resultExecutor)
: base(options)
{
Check.IfNullOrZero(options);
_options = options.Value;
JoinComponents = new List <JoinComponent>();
_resultExecutor = resultExecutor;
}
public ICommandExecutor GetCommandExecutor(IModuleBuilder moduleBuilder, ICommandBuilder commandBuilder)
{
var type = commandBuilder.MethodInfo.ReturnType;
var asyncResultType = commandBuilder.AsyncResultType;
if (commandBuilder.IsAsync)
{
if (type == typeof(Task) && commandBuilder.AsyncResultType.HasNoContent())
{
return(VoidTaskExecutor.Create(moduleBuilder, commandBuilder));
}
if (type == typeof(ValueTask) && commandBuilder.AsyncResultType.HasNoContent())
{
return(VoidValueTaskExecutor.Create(moduleBuilder, commandBuilder));
}
var genericDefinition = type.GetGenericTypeDefinition();
if (genericDefinition == typeof(Task <>) && typeof(IResult).IsAssignableFrom(asyncResultType))
{
return(ResultTaskExecutor.Create(moduleBuilder, commandBuilder));
}
if (genericDefinition == typeof(ValueTask <>) && typeof(IResult).IsAssignableFrom(asyncResultType))
{
return(ResultValueTaskExecutor.Create(moduleBuilder, commandBuilder));
}
if (genericDefinition == typeof(ValueTask <>))
{
return(ObjectValueTaskExecutor.Create(moduleBuilder, commandBuilder));
}
return(ObjectTaskExecutor.Create(moduleBuilder, commandBuilder));
}
if (type == typeof(void))
{
return(VoidExecutor.Create(moduleBuilder, commandBuilder));
}
if (typeof(IResult).IsAssignableFrom(type))
{
return(ResultExecutor.Create(moduleBuilder, commandBuilder));
}
return(ObjectExecutor.Create(moduleBuilder, commandBuilder));
}
public void ExecuteThrowsExceptionWithNullContextTest()
{
var mvcOptions = new MvcOptions();
var options = Substitute.For <IOptions <MvcOptions> >();
options.Value.Returns(mvcOptions);
var writerFactory = Substitute.For <IHttpResponseStreamWriterFactory>();
var loggerFactory = Substitute.For <ILoggerFactory>();
var formatSelector = new DefaultOutputFormatterSelector(options, loggerFactory);
var executor = new ObjectResultExecutor(formatSelector, writerFactory, loggerFactory);
var result = new ObjectResult(Guid.NewGuid().ToString());
var sut = new ResultExecutor(executor);
Func <Task> action = async() => await sut.Execute(null, result).ConfigureAwait(false);
action.Should().Throw <ArgumentNullException>();
}
public async Task ExecuteSendsResultToExecutorTest()
{
const HttpStatusCode StatusCode = HttpStatusCode.OK;
var mvcOptions = new MvcOptions();
var options = Substitute.For <IOptions <MvcOptions> >();
mvcOptions.OutputFormatters.Add(new StringOutputFormatter());
options.Value.Returns(mvcOptions);
var writerFactory = Substitute.For <IHttpResponseStreamWriterFactory>();
var loggerFactory = Substitute.For <ILoggerFactory>();
var formatSelector = new DefaultOutputFormatterSelector(options, loggerFactory);
var executor = Substitute.For <ObjectResultExecutor>(formatSelector, writerFactory, loggerFactory);
var result = new ObjectResult(Guid.NewGuid().ToString())
{
StatusCode = (int)StatusCode
};
var context = Substitute.For <HttpContext>();
var response = Substitute.For <HttpResponse>();
var headers = new HeaderDictionary();
var body = Substitute.For <Stream>();
response.HasStarted.Returns(false);
response.HttpContext.Returns(context);
response.Headers.Returns(headers);
response.Body.Returns(body);
context.Response.Returns(response);
var sut = new ResultExecutor(executor);
await sut.Execute(context, result).ConfigureAwait(false);
response.StatusCode.Should().Be((int)StatusCode);
await executor.Received().ExecuteAsync(
Arg.Is <ActionContext>(x => x.HttpContext == context),
Arg.Is <ObjectResult>(x => x == result)).ConfigureAwait(false);
}
public UpdateComponent(IOptions <EntityMapperOptions> options, ResultExecutor resultExecutor) : base(options)
{
_options = options.Value;
_resultExecutor = resultExecutor;
}
