public void Constructor_Valid()
{
// Arrange
var message = "FooBar";
var code = "some-error-code";
var level = ValidationIssueLevel.Error;
var names = ImmutableHashSet.Create("Foo", "Bar");
// Act
var issue = new ValidationIssue(
message: message,
code: code,
level: level,
memberNames: names
);
// Assert
Assert.Equal(message, issue.Message);
Assert.Equal(code, issue.Code);
Assert.Equal(level, issue.Level);
Assert.Equal(names, issue.MemberNames);
}
private IEnumerable <ValidationIssue> GenerateValidationIssues(int numberOfIssues)
{
foreach (var _ in Enumerable.Range(0, numberOfIssues))
{
yield return(ValidationIssue.Error(Guid.NewGuid().ToString()));
}
}
public TExecutionResult AddValidationIssue(ValidationIssue validationIssue)
{
if (validationIssue == null)
{
throw new ArgumentNullException(nameof(validationIssue));
}
return(this.AddValidationIssues(ImmutableHashSet.Create(validationIssue)));
}
private static ImmutableHashSet <ValidationIssue> ToSet(ValidationIssue issue)
{
if (issue == null)
{
throw new ArgumentNullException(nameof(issue));
}
return(ImmutableHashSet.Create <ValidationIssue>(issue));
}
public void Warning_WhiteSpaceMessage()
{
// Act
var exception = Record.Exception(
() => ValidationIssue.Warning(" \t")
);
// Assert
Assert.IsType <ArgumentException>(exception);
}
public void Warning_NullMessage()
{
// Act
var exception = Record.Exception(
() => ValidationIssue.Warning(null)
);
// Assert
Assert.IsType <ArgumentNullException>(exception);
}
private static String FormatIssueMessage(ValidationIssue issue)
{
var members = issue.MemberNames ?? ImmutableHashSet <String> .Empty;
var memberNames = String.Join(", ", members);
var message = String.Empty;
if (!String.IsNullOrWhiteSpace(memberNames))
{
message += $"Member(s): {memberNames}\n";
}
return($"{message}{issue.Level} Message: {issue.Message}");
}
public TExecutionResult AddWarning(
String message,
String code = default(String),
ISet <String> memberNames = default(ImmutableHashSet <String>))
{
return(this.AddValidationIssue(
ValidationIssue.Warning(
message: message,
code: code,
memberNames: memberNames
)
));
}
public void SetCode_AllStringsAreValid(string newCode)
{
// Arrange
var initial = ValidationIssue.Warning("Bar", "Code?");
// Act
var updated = initial.SetCode(newCode);
// Assert
Assert.Equal(newCode, updated.Code);
}
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 static TExecutionResult AddValidationResult <TExecutionResult>(
this OperationResultBase <TExecutionResult> operationResult,
ValidationResult validationResult)
where TExecutionResult : OperationResultBase <TExecutionResult>
{
var memberNames = validationResult.MemberNames ?? ImmutableHashSet <String> .Empty;
var issue = new ValidationIssue(
message: validationResult.ErrorMessage,
level: ValidationIssueLevel.Error,
memberNames: memberNames.ToImmutableHashSet()
);
return(operationResult.AddValidationIssue(issue));
}
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 IsSuccessful_TrueWithWarnings_NonGeneric()
{
// Arrange
const string message = "WarnFoo";
var validationIssues = ImmutableHashSet.Create(ValidationIssue.Warning(message));
// Act
var result = new OperationResult(validationIssues);
// Assert
Assert.True(result.IsSuccessful);
Assert.NotEmpty(result.ValidationIssues);
}
public void Constructor_NullValidationIssue()
{
// Arrange
ValidationIssue issue = null;
// Act
var exception = Record.Exception(
() => new ValidationIssueException(issue)
);
// Assert
Assert.IsType <ArgumentNullException>(exception);
}
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 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 SetMessage_NullMessage()
{
// Arrange
var issue = ValidationIssue.Error("FooBar");
// Act
var exception = Record.Exception(
() => issue.SetMessage(null)
);
// Assert
Assert.IsType <ArgumentNullException>(exception);
}
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 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 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 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 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 Warning_WithJustCode()
{
// Arrange
var message = "FooBar";
var code = "some-code";
// Act
var warning = ValidationIssue.Warning(message, code);
// Assert
Assert.Equal(message, warning.Message);
Assert.Equal(ValidationIssueLevel.Warning, warning.Level);
Assert.Equal(code, warning.Code);
Assert.Null(warning.MemberNames);
}
public void Warning_WithJustMemberNames()
{
// Arrange
var message = "FooBar";
var memberNames = ImmutableHashSet.Create("foo", "bar");
// Act
var warning = ValidationIssue.Warning(message, memberNames);
// Assert
Assert.Equal(message, warning.Message);
Assert.Equal(ValidationIssueLevel.Warning, warning.Level);
Assert.Null(warning.Code);
Assert.Equal(memberNames, warning.MemberNames);
}
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_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 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 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);
}
