/// <summary>
/// Executes the test case method.
/// </summary>
/// <param name="testClass">An instance of the class that contains the test case method.</param>
/// <returns>The <see cref="MethodResult"/> of executing the test case method.</returns>
public override MethodResult Execute(object testClass)
{
ITestClass theTestClass = testClass as ITestClass;
if (null != theTestClass)
{
MethodResult result = null;
try
{
theTestClass.TestInitialize(this.Namespace, this.Class, this.Method);
result = base.Execute(testClass);
}
catch (Exception ex)
{
// Return test failure to avoid extra break when debugging.
result = new FailedResult(this.testMethod, ex, null);
}
finally
{
theTestClass.TestUninitialize(result);
}
return(result);
}
return(base.Execute(testClass));
}
public void ToXml_WithChildren()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
ClassResult classResult = new ClassResult(typeof(object));
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
AssemblyResult assemblyResult = new AssemblyResult(filename);
assemblyResult.Add(classResult);
XmlNode resultNode = assemblyResult.ToXml(parentNode);
Assert.Equal("3.300", resultNode.Attributes["time"].Value);
Assert.Equal("3", resultNode.Attributes["total"].Value);
Assert.Equal("1", resultNode.Attributes["passed"].Value);
Assert.Equal("1", resultNode.Attributes["failed"].Value);
Assert.Equal("1", resultNode.Attributes["skipped"].Value);
Assert.Single(resultNode.SelectNodes("class"));
}
public void ToXml()
{
Exception ex = new Exception();
try
{
ThrowAnException();
}
catch (Exception e)
{
ex = e;
}
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
MethodInfo method = typeof(StubClass).GetMethod("StubMethod");
FailedResult failedResult = new FailedResult(Reflector.Wrap(method), ex, null);
failedResult.ExecutionTime = 1.2;
XmlNode resultNode = failedResult.ToXml(parentNode);
Assert.Equal("Fail", resultNode.Attributes["result"].Value);
Assert.Equal("1.200", resultNode.Attributes["time"].Value);
XmlNode failureXmlNode = resultNode.SelectSingleNode("failure");
Assert.NotNull(failureXmlNode);
Assert.Equal(ex.GetType().FullName, failureXmlNode.Attributes["exception-type"].Value);
Assert.Equal(ex.GetType().FullName + " : " + ex.Message, failureXmlNode.SelectSingleNode("message").InnerText);
Assert.Equal(ex.StackTrace, failureXmlNode.SelectSingleNode("stack-trace").InnerText);
Assert.Null(resultNode.SelectSingleNode("reason"));
}
/// <inheritdoc />
public async Task <IExecutionResult> RemoveConstraintAsync(string indexName, string value)
{
if (!cache.ContainsKey(indexName))
{
var customMessage = $"indexName: {indexName} not registered";
return(FailedResult.Create(
CoreErrorCodes.UnhandledError,
CoreErrorCodes.NameIsNotFound,
customMessage));
}
if (!cache[indexName].Contains(value))
{
var customMessage = $"no such value: {value} for indexName: {indexName}";
return(FailedResult.Create(
CoreErrorCodes.UnhandledError,
CoreErrorCodes.NameIsNotFound,
customMessage));
}
cache[indexName].Remove(value);
return(await Task.FromResult(new SuccessfulResult()));
}
public void ToXmlTwiceDoesNotDoubleCounts()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
ClassResult classResult = new ClassResult(typeof(object));
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
XmlNode resultNode1 = classResult.ToXml(parentNode);
XmlNode resultNode2 = classResult.ToXml(parentNode);
Assert.Equal(resultNode1.Attributes["time"].Value, resultNode2.Attributes["time"].Value);
Assert.Equal(resultNode1.Attributes["total"].Value, resultNode2.Attributes["total"].Value);
Assert.Equal(resultNode1.Attributes["passed"].Value, resultNode2.Attributes["passed"].Value);
Assert.Equal(resultNode1.Attributes["failed"].Value, resultNode2.Attributes["failed"].Value);
Assert.Equal(resultNode1.Attributes["skipped"].Value, resultNode2.Attributes["skipped"].Value);
Assert.Equal(resultNode1.SelectNodes("test").Count, resultNode2.SelectNodes("test").Count);
}
/// <summary>
/// Extension that filters needed internal errors and fills sources if needed.
/// </summary>
/// <typeparam name="TCommand">Type of command.</typeparam>
/// <param name="executionResult">Failed Execution Result.</param>
/// <returns>Filed FailedResult with correct Source.</returns>
public static IExecutionResult ForCommand <TCommand>(this IExecutionResult executionResult)
where TCommand : ICommand
{
if (!(executionResult is FailedResult failedResult))
{
return(executionResult);
}
var commandName = typeof(TCommand).Name;
var result = new FailedResult(failedResult.CodeInfo, commandName, failedResult.Message);
// Don't take internal errors if source used for another command.
foreach (var error in failedResult.Details)
{
if (!(string.IsNullOrEmpty(error.Source) || error.Source.Contains(commandName)))
{
// We don't need to take internal error used for another command.
continue;
}
var internalSource = string.IsNullOrEmpty(error.Source)
? typeof(TCommand).Name
: error.Source;
var newInternalError = new ExecutionError(error.CodeInfo, internalSource, error.Message);
result.AddError(newInternalError);
}
return(result);
}
public CommandFailedEventArgs(FailedResult res, VolteContext ctx, string args,
Stopwatch sw)
{
FailedResult = res;
Context = ctx;
Arguments = args;
Stopwatch = sw;
}
public CommandFailedEventArgs(FailedResult res, CommandCalledEventArgs args)
{
Result = res;
Context = args.Context;
Arguments = args.Arguments;
Command = args.Command;
Stopwatch = args.Stopwatch;
}
public void Uninitialized()
{
FailedResult <DomainError> failedResult = new FailedResult <DomainError>();
failedResult.Should().BeOfType <FailedResult <DomainError> >();
failedResult.IsSuccess.Should().BeFalse();
failedResult.IsFailed.Should().BeTrue();
Static.GetValue(() => failedResult.ErrorValue).Should().Throw <NotInitializedException>();
}
private static void UpdateFailedResultWithArrayElementsDetails(
FailedResult outputResultToUpdate,
PropertyInfo collectionProperty,
Type instanceType,
object collectionValue)
{
if (collectionValue == null)
{
return;
}
var attributesFromValidateCollection = CustomAttributeExtensions.GetCustomAttributes(collectionProperty, true)
.OfType <ValidateCollectionAttribute>()
.Select(a => a.InlineAttribute)
.ToList();
var counter = -1;
foreach (var arrayElement in (System.Collections.IEnumerable)collectionValue)
{
counter++;
if (arrayElement == null)
{
if (attributesFromValidateCollection.Any(a => a.GetType() == typeof(RequiredAttribute)))
{
var source = $"{instanceType.Name}.{collectionProperty.Name}.{counter}";
outputResultToUpdate.AddError(new ExecutionError(AnnotationErrorCodes.Required, source));
}
continue;
}
// Validate every array element itself.
var arrayResultErrors = CoreValidator.GetValidationErrors(arrayElement, new ValidationContext(arrayElement), attributesFromValidateCollection, false);
foreach (var arrayElementError in arrayResultErrors)
{
var source = $"{instanceType.Name}.{collectionProperty.Name}.{counter}";
outputResultToUpdate.AddError(new ExecutionError(arrayElementError.CodeInfo, source));
}
var arrayType = arrayElement.GetType();
if (arrayType.IsPrimitive || arrayType == typeof(decimal) || arrayType == typeof(string))
{
continue;
}
// Validate properties of an array element recursively if it's not an primitive type.
var propertyResult = Validate(arrayElement);
if (!(propertyResult is FailedResult fr))
{
continue;
}
UpdateFailedResultWithDetails(outputResultToUpdate, fr, collectionProperty, instanceType, counter);
}
}
public void FactMethodsCannotHaveArguments()
{
MethodResult result = RunClass(typeof(ClassUnderTest)).Single();
FailedResult failedResult = Assert.IsType <FailedResult>(result);
Assert.Equal(typeof(InvalidOperationException).FullName, failedResult.ExceptionType);
Assert.Equal("System.InvalidOperationException : Fact method Xunit1.FactMethodWithArgumentsTests+ClassUnderTest.FactWithParameters cannot have parameters", failedResult.Message);
}
public void ThrowingData()
{
MethodResult result = RunClass(typeof(ThrowingDataClass)).Single();
FailedResult failedResult = Assert.IsType <FailedResult>(result);
Assert.Equal(@"Xunit1.Extensions.TheoryAcceptanceTests+ThrowingDataClass.TheoryWithMisbehavingData", failedResult.DisplayName);
Assert.Contains("System.InvalidOperationException : An exception was thrown while getting data for theory Xunit1.Extensions.TheoryAcceptanceTests+ThrowingDataClass.TheoryWithMisbehavingData", failedResult.Message);
}
public void Async40AcceptanceTest()
{
IEnumerable <MethodResult> results = RunClass(typeof(Async40AcceptanceTestClass));
MethodResult result = Assert.Single(results);
FailedResult failedResult = Assert.IsType <FailedResult>(result);
Assert.Equal(typeof(TrueException).FullName, failedResult.ExceptionType);
}
public void TestHasTimeoutAndExceeds()
{
MethodResult result = RunClass(typeof(ClassUnderTest)).Single();
FailedResult failedResult = Assert.IsType <FailedResult>(result);
Assert.InRange(failedResult.ExecutionTime, 0.049, 0.051);
Assert.Equal("Test execution time exceeded: 50ms", failedResult.Message);
}
public void EmptyTheoryData()
{
MethodResult result = RunClass(typeof(EmptyTheoryDataClass)).Single();
FailedResult failedResult = Assert.IsType <FailedResult>(result);
Assert.Equal(@"Xunit1.Extensions.TheoryAcceptanceTests+EmptyTheoryDataClass.TheoryMethod", failedResult.DisplayName);
Assert.Equal("System.InvalidOperationException : No data found for Xunit1.Extensions.TheoryAcceptanceTests+EmptyTheoryDataClass.TheoryMethod", failedResult.Message);
}
/// <summary>
/// Validates instance using DataAnnotations.
/// </summary>
/// <param name="instance">Validated instance.</param>
/// <returns><see cref="FailedResult"/> if invalid, otherwise <see cref="SuccessfulResult"/>.</returns>
public static IExecutionResult Validate(object instance)
{
if (instance == null)
{
return(new SuccessfulResult());
}
var validationContext = new ValidationContext(instance);
var executionErrors = new List <ExecutionError>();
// Validate current level of the instance.
CoreValidator.TryValidateObject(instance, validationContext, executionErrors, true);
var instanceType = instance.GetType();
var result = new FailedResult(CoreErrorCodes.ValidationFailed, instanceType.Name);
foreach (var executionError in executionErrors)
{
var field = executionError.Source ?? string.Empty;
var source = $"{instanceType.Name}.{field}";
var error = new ExecutionError(executionError.CodeInfo, source);
result.AddError(error);
}
// Recursively validate nested types.
var properties = instanceType
.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty)
.Where(PropertyCanBeValidated);
foreach (var property in properties)
{
var propertyValue = property.GetValue(instance);
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(property.PropertyType))
{
UpdateFailedResultWithArrayElementsDetails(result, property, instanceType, propertyValue);
continue;
}
var propertyResult = Validate(propertyValue);
if (!(propertyResult is FailedResult fr))
{
continue;
}
UpdateFailedResultWithDetails(result, fr, property, instanceType);
}
return(result.Details.Any()
? (IExecutionResult)result
: new SuccessfulResult());
}
public void ForCommand_NoInnerDetails_ReturnsResultWithCorrectSource()
{
var input = new FailedResult(CoreErrorCodes.ValidationFailed);
var result = input.ForCommand <TestCommand>(c => c.AggregateRootId);
var failedResult = (FailedResult)result;
failedResult.Source.Should().Be("TestCommand.AggregateRootId");
failedResult.Message.Should().Be(input.Message);
failedResult.Code.Should().Be(input.Code);
failedResult.CodeInfo.Should().BeEquivalentTo(input.CodeInfo);
}
public void FailedResultSerializeTest()
{
var input = new FailedResult(CoreErrorCodes.ValidationFailed, "Some source", "Some message");
var json = input.ToJson();
var deserialized = json.FromJson <FailedResult>();
deserialized.Message.Should().Be(input.Message);
deserialized.Code.Should().Be(input.Code);
deserialized.Source.Should().Be(input.Source);
deserialized.CodeInfo.Should().BeEquivalentTo(input.CodeInfo);
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationFailedSignal"/> class.
/// </summary>
/// <param name="source">Source.</param>
/// <param name="error">Error.</param>
public OperationFailedSignal(IMessage source, FailedResult error)
{
Source = source ?? throw new ArgumentNullException($"Source in the OperationFailedSignal should be set");
Error = error ?? throw new ArgumentNullException($"FailedResult in the OperationFailedSignal should be set");
Id = Unified.NewCode();
AggregateRootId = source.AggregateRootId;
CorrelationId = source.CorrelationId;
Actor = source.Actor;
source.CopyMetadata(this);
}
public void Test_FailedResult()
{
// Act.
var result = new FailedResult(
TimeSpan.FromMilliseconds(13),
new ExceptionScriptError(new InvalidOperationException()));
// Assert.
Assert.Equal(TimeSpan.FromMilliseconds(13), result.Duration);
Assert.IsType <InvalidOperationException>(result.Reason.Exception);
Assert.Equal(TestStatus.Failed, result.Status);
}
public void IncorrectParameterCount()
{
MethodResult[] results = RunClass(typeof(IncorrectParameterCountClass)).ToArray();
Assert.Equal(2, results.Length);
PassedResult passedResult = results.OfType <PassedResult>().Single();
Assert.Equal(@"Xunit1.Extensions.TheoryAcceptanceTests+IncorrectParameterCountClass.PassingTestData(x: 1)", passedResult.DisplayName);
FailedResult failedResult = results.OfType <FailedResult>().Single();
Assert.Equal(@"Xunit1.Extensions.TheoryAcceptanceTests+IncorrectParameterCountClass.PassingTestData(x: 2, ???: 3)", failedResult.DisplayName);
}
public void MultipleDataSets()
{
MethodResult[] results = RunClass(typeof(MultipleDataSetsClass)).ToArray();
Assert.Equal(2, results.Length);
PassedResult passedResult = results.OfType <PassedResult>().Single();
Assert.Equal(@"Xunit1.Extensions.InlineDataAcceptanceTests+MultipleDataSetsClass.PassingTestData(foo: 1, bar: ""hello"", baz: 2.3)", passedResult.DisplayName);
FailedResult failedResult = results.OfType <FailedResult>().Single();
Assert.Equal(@"Xunit1.Extensions.InlineDataAcceptanceTests+MultipleDataSetsClass.PassingTestData(foo: 42, bar: ""world"", baz: 21.12)", failedResult.DisplayName);
}
public void ValidationFailed_WithCollectionOfErrors_ReturnResultWithSameInternalErrors()
{
var executionErrors = new[]
{
new ExecutionError(new ErrorCodeInfo(nameof(Core), FixtureUtils.String(), FixtureUtils.String())),
new ExecutionError(new ErrorCodeInfo(nameof(Core), FixtureUtils.String(), FixtureUtils.String()))
};
var result = FailedResult.ValidationFailed(executionErrors);
result.CodeInfo.Should().BeEquivalentTo(CoreErrorCodes.ValidationFailed);
result.Details.Should().BeEquivalentTo <ExecutionError>(executionErrors);
}
public void TestTookTooLongFailedResult()
{
Mock<ITestCommand> testCommand = new Mock<ITestCommand>();
testCommand
.Setup(tc => tc.Execute(null))
.Callback<object>(_ => Thread.Sleep(500));
TimeoutCommand command = new TimeoutCommand(testCommand.Object, 20, GetMethodInfo());
MethodResult result = command.Execute(null);
FailedResult failedResult = Assert.IsType<FailedResult>(result);
Assert.Equal("Test execution time exceeded: 20ms", failedResult.Message);
}
private static IMessageSinkMessage Map(FailedResult result)
{
if (result == null)
{
return(null);
}
var message = A.Fake <ITestFailed>();
A.CallTo(() => message.Test.DisplayName).Returns(result.DisplayName);
A.CallTo(() => message.Messages).Returns(new[] { result.Message });
A.CallTo(() => message.ExceptionTypes).Returns(new[] { result.ExceptionType });
A.CallTo(() => message.StackTraces).Returns(new[] { result.StackTrace });
return(message);
}
public void ShouldWrapExceptionDetailsWhenExceptionIsThrown()
{
ExceptionThrowingCommand innerCmd = new ExceptionThrowingCommand();
MethodInfo method = typeof(ExceptionThrowingCommand).GetMethod("Execute");
var command = new ExceptionAndOutputCaptureCommand(innerCmd, Reflector.Wrap(method));
MethodResult result = command.Execute(null);
FailedResult failed = Assert.IsType <FailedResult>(result);
Assert.Equal(method.Name, failed.MethodName);
Assert.Equal(method.DeclaringType.FullName, failed.TypeName);
Assert.Equal(typeof(TargetInvocationException).FullName, failed.ExceptionType);
Assert.Contains("ExceptionThrowingCommand.Execute", failed.StackTrace);
}
public override MethodResult Execute(object testClass)
{
MethodResult result = null;
try
{
result = InnerCommand.Execute(testClass);
}
catch (Exception ex)
{
result = new FailedResult(_method, ex, DisplayName);
}
return(result);
}
public void CreateWithInternal_Creates_2LevelError()
{
var externalCode = new ErrorCodeInfo(nameof(Core), FixtureUtils.String(), FixtureUtils.String());
var internalCode = new ErrorCodeInfo(nameof(Core), FixtureUtils.String(), FixtureUtils.String());
var result = FailedResult.Create(externalCode, internalCode);
result.Code.Should().Be(externalCode.Code);
result.Message.Should().Be(externalCode.Message);
var internalError = result.Details.Single();
internalError.Message.Should().Be(internalCode.Message);
internalError.Code.Should().Be(internalCode.Code);
}
protected override HttpResponseMessage DomainExceptionHandling(DomainException exception)
{
switch (exception)
{
case EntityException ee:
var failure = new FailedResult(ee.Message);
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new JsonContent(failure, JsonSerializerProfile.Default)
});
default:
return(base.DomainExceptionHandling(exception));
}
}
public void InitializeFailedResult()
{
Type stubType = typeof(StubClass);
MethodInfo method = stubType.GetMethod("StubMethod");
StubException stubException = new StubException("Message", "StackTrace");
FailedResult result = new FailedResult(Reflector.Wrap(method), stubException, null);
result.ExecutionTime = 1.2;
Assert.Equal("StubMethod", result.MethodName);
Assert.Equal(stubType.FullName, result.TypeName);
Assert.Equal(typeof(StubException).FullName + " : Message", result.Message);
Assert.Equal(1.2, result.ExecutionTime);
Assert.Equal("StackTrace", result.StackTrace);
}
