public void Given_Errors_Expect_Non_Null_Error_Object()
{
//---------------Arrange-------------------
var errors = new ErrorOutput();
errors.AddError("Test error 1");
errors.AddError("Test error 2");
var presenter = new ErrorOnlyPropertyPresenter <ErrorOutput>();
//---------------Act-------------------
presenter.Respond(errors);
//---------------Assert-------------------
presenter.Output.Should().NotBeNull();
}
public void Given_There_Are_Errors_On_Inner_Execute__Expect_Errors_Transfered_To_Outer_Object()
{
//---------------Arrange-------------------
var input = new RandomPersonInput
{
MinAge = 19,
MaxAge = 19,
ForceError = true
};
var useCase = new GenerateRandomPersonUseCase();
var outerPresenter = new PropertyPresenter <OuterTestObject, ErrorOutput>();
var innerPresenter = new InterUseCasePresenter <OuterTestObject, InnerTestObject, ErrorOutput>();
//---------------Act-------------------
useCase.Execute(input, innerPresenter);
innerPresenter.Render(x => new OuterTestObject
{
Age = x.Age,
FullName = $"{x.FirstName} {x.LastName}"
}, outerPresenter);
//---------------Assert-------------------
var expected = new ErrorOutput();
expected.AddError("Forced error happened");
outerPresenter.ErrorContent.Should().BeEquivalentTo(expected);
}
public void Execute(string input, IRespondWithSuccessOrError <string, ErrorOutput> presenter)
{
var processStartInfo = _processPipeLineTask.CommandToExecute();
try
{
using (var process = _processFactory.CreateProcess(processStartInfo))
{
process.Start();
var readerTask = process.ReadStdOutToEndAsync();
var errorTask = process.ReadStdErrToEndAsync();
process.WriteToStdInput(input);
process.WaitForExit(_processPipeLineTask.ProcessTimeout());
if (process.TimeoutOccured)
{
var errorOutput = new ErrorOutput();
errorOutput.AddError($"The process timed out after waiting [{_processPipeLineTask.ProcessTimeout()}] seconds.");
return;
}
var error = errorTask.Result;
if (HasError(error))
{
var errorOutput = new ErrorOutput();
var trimedArugments = processStartInfo.Arguments.Substring(3);
errorOutput.AddError($"Failed to execute {trimedArugments}");
errorOutput.AddError(error);
presenter.Respond(errorOutput);
return;
}
presenter.Respond(readerTask.Result);
}
}
catch (Exception e)
{
throw new Exception($"Failed to execute [{processStartInfo.FileName}] with [{processStartInfo.Arguments}]", e);
}
}
public void Given_Not_Null_String_Expect_It_Not_Added_To_Errors()
{
//---------------Arrange-------------------
var error = "an error";
var sut = new ErrorOutput();
//---------------Act-------------------
sut.AddError(error);
//---------------Assert-------------------
sut.Errors.Should().Contain(error);
}
public void Given_Null_String_Expect_It_Not_Added_To_Errors()
{
//---------------Arrange-------------------
var error = (string)null;
var sut = new ErrorOutput();
//---------------Act-------------------
sut.AddError(error);
//---------------Assert-------------------
sut.Errors.Should().BeEmpty();
}
public void HasErrors_WhenErrors_ShouldReturnTrue()
{
//---------------Arrange-------------------
var errorOutputTo = new ErrorOutput();
errorOutputTo.AddError("test error");
//---------------Act-------------------
var result = errorOutputTo.HasErrors;
//---------------Assert-------------------
Assert.True(result);
}
public void Given_Not_Null_String_Expect_It_Added_To_Errors()
{
//---------------Arrange-------------------
var error = "an error";
var sut = new ErrorOutput();
//---------------Act-------------------
sut.AddError(error);
//---------------Assert-------------------
sut.Errors.Should().BeEquivalentTo(new List <string> {
error
});
}
private void Execute(IRespondWithNoResultSuccessOrError <ErrorOutput> presenter)
{
var processStartInfo = _processPipeLineTask.CommandToExecute();
try
{
_process = _processFactory.CreateBackgroundProcess(processStartInfo);
_process.Start();
var errorTask = _process.ReadStdErrToEndAsync();
if (!errorTask.Wait(500))
{
// was there error data to fetch?
presenter.Respond();
return;
}
var error = errorTask.Result;
if (HasError(error))
{
var errorOutput = new ErrorOutput();
var trimedArugments = processStartInfo.Arguments.Substring(3);
errorOutput.AddError($"Failed to execute {trimedArugments}");
errorOutput.AddError(error);
presenter.Respond(errorOutput);
return;
}
presenter.Respond();
}
catch (Exception e)
{
throw new Exception($"Failed to execute [{processStartInfo.FileName}] with [{processStartInfo.Arguments}]", e);
}
}
public void Execute(RandomPersonInput inputTo, IRespondWithSuccessOrError <InnerTestObject, ErrorOutput> presenter)
{
if (inputTo.ForceError)
{
var errors = new ErrorOutput();
errors.AddError("Forced error happened");
presenter.Respond(errors);
return;
}
var random = new Random(11223);
presenter.Respond(new InnerTestObject
{
Age = random.Next(inputTo.MinAge, inputTo.MaxAge),
FirstName = "Test",
LastName = "User"
});
}
