private IEnumerable <ValidationIssue> GenerateValidationIssues(int numberOfIssues)
{
foreach (var _ in Enumerable.Range(0, numberOfIssues))
{
yield return(ValidationIssue.Error(Guid.NewGuid().ToString()));
}
}
public void Error_NullMessage()
{
// Act
var exception = Record.Exception(
() => ValidationIssue.Error(null)
);
// Assert
Assert.IsType <ArgumentNullException>(exception);
}
public void Error_WhiteSpaceMessage()
{
// Act
var exception = Record.Exception(
() => ValidationIssue.Error(" \t")
);
// Assert
Assert.IsType <ArgumentException>(exception);
}
public TExecutionResult AddError(
String message,
String code = default(String),
ISet <String> memberNames = default(ImmutableHashSet <String>))
{
return(this.AddValidationIssue(
ValidationIssue.Error(
message: message,
code: code,
memberNames: memberNames
)
));
}
public void SetLevel_Valid()
{
// Arrange
var initial = ValidationIssue.Error("Foo");
// Act
var updated = initial.SetLevel(ValidationIssueLevel.Warning);
// Assert
Assert.Equal(ValidationIssueLevel.Error, initial.Level);
Assert.Equal(ValidationIssueLevel.Warning, updated.Level);
}
public void SetMessage_Valid()
{
// Arrange
var initial = ValidationIssue.Error("Foo");
// Act
var updated = initial.SetMessage("FooBar");
// Assert
Assert.Equal("Foo", initial.Message);
Assert.Equal("FooBar", updated.Message);
}
public void SetMessage_WhiteSpaceMessage()
{
// Arrange
var issue = ValidationIssue.Error("FooBar");
// Act
var exception = Record.Exception(
() => issue.SetMessage(" \n")
);
// Assert
Assert.IsType <ArgumentException>(exception);
}
public void SetMessage_NullMessage()
{
// Arrange
var issue = ValidationIssue.Error("FooBar");
// Act
var exception = Record.Exception(
() => issue.SetMessage(null)
);
// Assert
Assert.IsType <ArgumentNullException>(exception);
}
public void Constructor_WithInnerException()
{
// Arrange
var issue = ValidationIssue.Error("Foo");
var innerException = new InvalidOperationException();
// Act
var exception = new ValidationIssueException(issue, innerException);
// Assert
Assert.NotNull(exception.InnerException);
Assert.Equal(innerException, exception.InnerException);
}
public void Constructor_NullInnerException()
{
// Arrange
var issue = ValidationIssue.Error("Foo");
// Act
var exception = Record.Exception(
() => new ValidationIssueException(issue, null)
);
// Assert
Assert.Null(exception);
}
public void ExceptionMessage_SingleIssue_Message()
{
// Arrange
var message = "Foo is beyond all reason.";
var issues = ImmutableHashSet.Create(
ValidationIssue.Error(message)
);
// Act
var exception = new OperationResultException(issues);
// Assert
Assert.Equal($"Error Message: {message}", exception.Message);
}
public void SetMemberNames_Valid()
{
// Arrange
var names = ImmutableHashSet.Create("Foo", "Bar");
var initial = ValidationIssue.Error("Foo", memberNames: names);
// Act
var nextNames = names.Add("Name");
var updated = initial.SetMemberNames(nextNames);
// Assert
Assert.DoesNotContain("Name", initial.MemberNames);
Assert.Contains("Name", updated.MemberNames);
}
public void Error_WithJustCode()
{
// Arrange
var message = "FooBar";
var code = "some-code";
// Act
var warning = ValidationIssue.Error(message, code);
// Assert
Assert.Equal(message, warning.Message);
Assert.Equal(ValidationIssueLevel.Error, warning.Level);
Assert.Equal(code, warning.Code);
Assert.Null(warning.MemberNames);
}
public void AddValidationIssue_ImmutableAndCombinesResults_Generic()
{
// Arrange
var validationIssueOne = ValidationIssue.Error("Foo");
var validationIssueTwo = ValidationIssue.Error("Bar");
var original = new OperationResult <Object>(ImmutableHashSet.Create(validationIssueOne));
// Act
var updated = original.AddValidationIssue(validationIssueTwo);
// Assert
Assert.NotEqual(original, updated);
Assert.Contains(validationIssueOne, updated.ValidationIssues);
Assert.Contains(validationIssueTwo, updated.ValidationIssues);
}
public void IsSuccessful_FalseWithResults_NonGeneric()
{
// Arrange
const string message = "Foo";
var validationIssues = ImmutableHashSet.Create(ValidationIssue.Error(message));
// Act
var result = new OperationResult(validationIssues);
// Assert
Assert.False(result.IsSuccessful);
var validationResult = Assert.Single(result.ValidationIssues);
Assert.Equal(message, validationResult.Message);
}
public void Constructor_NullInnerException()
{
// Arrange
var issues = ImmutableHashSet.Create(
ValidationIssue.Error("Foo")
);
// Act
var exception = Record.Exception(
() => new OperationResultException(issues, null)
);
// Assert
Assert.Null(exception);
}
public void Error_WithJustMemberNames()
{
// Arrange
var message = "FooBar";
var memberNames = ImmutableHashSet.Create("foo", "bar");
// Act
var warning = ValidationIssue.Error(message, memberNames);
// Assert
Assert.Equal(message, warning.Message);
Assert.Equal(ValidationIssueLevel.Error, warning.Level);
Assert.Null(warning.Code);
Assert.Equal(memberNames, warning.MemberNames);
}
public void Constructor_Valid()
{
// Arrange
var issue = ValidationIssue.Error("Foo");
// Act
var exception = new ValidationIssueException(issue);
// Assert
Assert.Null(exception.InnerException);
Assert.NotNull(exception.OperationResult);
Assert.NotNull(exception.OperationResult.ValidationIssues);
var actualIssue = Assert.Single(exception.OperationResult.ValidationIssues);
Assert.Equal(issue, actualIssue);
}
public void ExceptionMessage_SingleIssue_Message_WithMembers()
{
// Arrange
var message = "Foo is beyond all reason.";
var names = ImmutableHashSet.Create("Foo", "Bar");
var issues = ImmutableHashSet.Create(
ValidationIssue.Error(message, memberNames: names)
);
// Act
var exception = new OperationResultException(issues);
// Assert
var memberNames = String.Join(", ", names);
Assert.Equal($"Member(s): {memberNames}\nError Message: {message}", exception.Message);
}
public void Constructor_InnerException()
{
// Arrange
var issues = ImmutableHashSet.Create(
ValidationIssue.Error("Foo")
);
var innerException = new InvalidOperationException();
// Act
var exception = new OperationResultException(
issues,
innerException
);
// Assert
Assert.Equal(issues, exception.OperationResult.ValidationIssues);
Assert.Equal(innerException, exception.InnerException);
}
public void AddError_VaryingSets_Generic(
int initialNumberOfValidationIssues)
{
// Arrange
var initialValidationIssues =
this.GenerateValidationIssues(initialNumberOfValidationIssues)
.ToImmutableHashSet();
var message = "FooBar";
var initial = new OperationResult <Object>(initialValidationIssues);
// Act
var updated = initial.AddError(message);
// Assert
var issue = ValidationIssue.Error(message);
Assert.Contains(issue, updated.ValidationIssues);
Assert.DoesNotContain(issue, initial.ValidationIssues);
}
public void ExceptionMessage_MultipleIssues_Message()
{
// Arrange
var message = "Foo is beyond all reason.";
var warningMessage = "What is Kung Fu Fighting?";
var names = ImmutableHashSet.Create("Foo", "Bar");
var issues = ImmutableHashSet.Create(
ValidationIssue.Error(message, memberNames: names),
ValidationIssue.Warning(warningMessage)
);
// Act
var exception = new OperationResultException(issues);
// Assert
var memberNames = String.Join(", ", names);
Assert.Contains($"Member(s): {memberNames}\nError Message: {message}", exception.Message);
Assert.Contains($"Warning Message: {warningMessage}", exception.Message);
}
public void Error_Valid()
{
// Arrange
var message = "FooBar";
var code = "bizz buzz barr";
var names = ImmutableHashSet.Create("Foo", "Bar");
// Act
var warning = ValidationIssue.Error(
message,
code,
names
);
// Assert
Assert.Equal(message, warning.Message);
Assert.Equal(ValidationIssueLevel.Error, warning.Level);
Assert.Equal(code, warning.Code);
Assert.Equal(names, warning.MemberNames);
}
public void AddError_VaryingSetsWithMembers_NonGeneric(
int initialNumberOfValidationIssues)
{
// Arrange
var initialValidationIssues =
this.GenerateValidationIssues(initialNumberOfValidationIssues)
.ToImmutableHashSet();
var message = "FooBar";
var memberNames = ImmutableHashSet.Create("Foo", "Bar");
var initial = new OperationResult(initialValidationIssues);
// Act
var updated = initial.AddError(message, memberNames: memberNames);
// Assert
var issue = ValidationIssue.Error(message, memberNames);
Assert.Contains(issue, updated.ValidationIssues);
Assert.DoesNotContain(issue, initial.ValidationIssues);
}
