public override (bool isValid, ErrorsCollection errors) ValidateObject(Money money)
{
var result = Validate(money);
var errors = result.Errors.Select(e => new ValidationError(e.ErrorCode, e.ErrorMessage));
return(result.IsValid, ErrorsCollection.Create(errors));
}
public void AddError_Should_AddInnerCollection_When_Multiple_To_SameMember_WithDuplicates()
{
var errorsCollection = new ErrorsCollection();
var innerCollection = new ErrorsCollection();
innerCollection.AddError("inner", new Error("test321"));
innerCollection.AddError("inner", new Error("foo"));
innerCollection.AddError("inner", new Error("bar"));
var innerCollection2 = new ErrorsCollection();
innerCollection2.AddError("inner", new Error("test123"));
innerCollection2.AddError("inner", new Error("test321"));
innerCollection2.AddError("inner", new Error("foo"));
errorsCollection.AddError("test", innerCollection);
errorsCollection.AddError("test", innerCollection2);
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection, new[] { "test" });
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection.Members["test"], new[] { "inner" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["test"].Members["inner"], new[] { "test321", "foo", "bar", "test123", "test321", "foo" });
Assert.False(errorsCollection.IsEmpty);
}
public void Should_InsertErrors()
{
Expression <Func <MemberClass, InnerClass> > selector = m => m.Inner;
var propertyInfo = (PropertyInfo)((MemberExpression)selector.Body).Member;
var memberScope = new MemberScope <MemberClass, InnerClass>(propertyInfo, m => m
.Valid(c => false).WithMessage("error1")
);
var target = new ErrorsCollection();
var scopeErrors = new ErrorsCollection();
scopeErrors.AddError(new Error("error1"));
memberScope.InsertErrors(target, scopeErrors);
Assert.Empty(target.Errors);
Assert.Equal(1, target.Members.Count);
Assert.Equal("error1", target.Members["Inner"].Errors.Single().Message);
Assert.Empty(target.Members["Inner"].Members);
}
public void ToModelReport_Should_Generate_RootMessages_And_MemberMessages_WithoutDuplicates()
{
var draft = new ErrorsCollection();
draft.AddError(new Error("foo"));
draft.AddError(new Error("bar"));
draft.AddError(new Error("bar"));
draft.AddError(new Error("foo"));
var innerDraft = new ErrorsCollection();
innerDraft.AddError("inner", new Error("test123"));
innerDraft.AddError("inner", new Error("test321"));
innerDraft.AddError("inner", new Error("test321"));
innerDraft.AddError("inner", new Error("test123"));
draft.AddError("test", innerDraft);
var report = ResultsTestHelpers.MockValidationResult(draft).ToModelReport() as ModelReport;
ExpectMembersInReport(report, new[] { string.Empty, "test" });
// ReSharper disable once PossibleNullReferenceException
ExpectMessagesInList(report[string.Empty] as ModelReportErrorsList, new[] { "foo", "bar" });
ExpectMembersInReport(report["test"] as ModelReport, new[] { "inner" });
// ReSharper disable once PossibleNullReferenceException
ExpectMessagesInList((report["test"] as ModelReport)["inner"] as ModelReportErrorsList, new[] { "test123", "test321" });
}
public IValidationResult <T> Merge(params IErrorsCollection[] errorsCollections)
{
if (errorsCollections == null)
{
throw new ArgumentNullException(nameof(errorsCollections));
}
if (errorsCollections.Contains(null))
{
throw new ArgumentException("Null in collection", nameof(errorsCollections));
}
var mergedErrorsCollection = new ErrorsCollection();
mergedErrorsCollection.Include(ErrorsCollection);
foreach (var errorsCollection in errorsCollections)
{
mergedErrorsCollection.Include(errorsCollection);
}
return(new ValidationResult <T>(ValidationContextId, TranslationProxy, ExecutionOptions, Model, mergedErrorsCollection)
{
IsMergeResult = true
});
}
public void ToModelReport_Should_Translate()
{
var draft = new ErrorsCollection();
draft.AddError(new Error("foo"));
draft.AddError(new Error("bar"));
var innerDraft = new ErrorsCollection();
innerDraft.AddError("inner", new Error("test123"));
innerDraft.AddError("inner", new Error("test321"));
draft.AddError("test", innerDraft);
var report = ResultsTestHelpers.MockValidationResult(draft, translations: new[]
{
new Translation("test", new Dictionary <string, string> {
{ "foo", "FOO" }, { "test123", "TEST123" }
}),
new Translation("test1", new Dictionary <string, string> {
{ "bar", "BAR" }, { "test321", "TEST321" }
})
}).ToModelReport("test") as ModelReport;
ExpectMembersInReport(report, new[] { string.Empty, "test" });
// ReSharper disable once PossibleNullReferenceException
ExpectMessagesInList(report[string.Empty] as ModelReportErrorsList, new[] { "FOO", "bar" });
ExpectMembersInReport(report["test"] as ModelReport, new[] { "inner" });
// ReSharper disable once PossibleNullReferenceException
ExpectMessagesInList((report["test"] as ModelReport)["inner"] as ModelReportErrorsList, new[] { "TEST123", "test321" });
}
public DomainException(ValidationError error)
{
Errors = ErrorsCollection.Create(new List <ValidationError>()
{
error
});
}
public void ToListReport_Should_ThrowException_When_InvalidTranslationName()
{
var errorsCollection = new ErrorsCollection();
var nestedErrorsCollection = new ErrorsCollection();
nestedErrorsCollection.AddError(new Error("test123"));
nestedErrorsCollection.AddError(new Error("test321"));
nestedErrorsCollection.AddError("inner", new Error("foo"));
nestedErrorsCollection.AddError("inner", new Error("bar"));
errorsCollection.AddError("test", nestedErrorsCollection);
var report = ResultsTestHelpers.MockValidationResult(errorsCollection, translations: new[]
{
new Translation("test", new Dictionary <string, string> {
{ "foo", "FOO" }, { "test123", "TEST123" }
}),
new Translation("test1", new Dictionary <string, string> {
{ "bar", "BAR" }, { "test321", "TEST321" }
})
});
Assert.Throws <TranslationNotFoundException>(() => { report.ToListReport("test_non_existing"); });
}
public void ToListReport_Should_Translate()
{
var errorsCollection = new ErrorsCollection();
var nestedErrorsCollection = new ErrorsCollection();
nestedErrorsCollection.AddError(new Error("test123"));
nestedErrorsCollection.AddError(new Error("test321"));
nestedErrorsCollection.AddError("inner", new Error("foo"));
nestedErrorsCollection.AddError("inner", new Error("bar"));
errorsCollection.AddError("test", nestedErrorsCollection);
var report = ResultsTestHelpers.MockValidationResult(errorsCollection, translations: new[]
{
new Translation("test", new Dictionary <string, string> {
{ "foo", "FOO" }, { "test123", "TEST123" }
}),
new Translation("test1", new Dictionary <string, string> {
{ "bar", "BAR" }, { "test321", "TEST321" }
})
}).ToListReport("test");
ExpectMembersInReport(report, "", new[] { "test" });
ExpectMessagesInReport(report, "test", new[] { "TEST123", "test321" });
ExpectMembersInReport(report, "test", new[] { "inner" });
ExpectMessagesInReport(report, "test.inner", new[] { "FOO", "bar" });
}
public void Include_Should_Include_When_ContainsSingleLevel()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("foo", new Error("test1"));
errorsCollection.AddError("foo", new Error("test2"));
errorsCollection.AddError("bar", new Error("test3"));
errorsCollection.AddError("bar", new Error("test4"));
var another = new ErrorsCollection();
another.AddError("foo", new Error("111"));
another.AddError("foo", new Error("222"));
another.AddError("bar", new Error("333"));
another.AddError("bar", new Error("444"));
another.AddError("X", new Error("555"));
another.AddError("Y", new Error("666"));
errorsCollection.Include(another);
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection, new[] { "foo", "bar", "X", "Y" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["foo"], new[] { "test1", "test2", "111", "222" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["bar"], new[] { "test3", "test4", "333", "444" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["X"], new[] { "555" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["Y"], new[] { "666" });
}
public void ToListReport_Should_LimitDepth(int maxDepth, bool expectException)
{
var level3 = new ErrorsCollection();
level3.AddError(new Error("error"));
var level2 = new ErrorsCollection();
level2.AddError("member2", level3);
var level1 = new ErrorsCollection();
level1.AddError("member1", level2);
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("member", level1);
var result = ResultsTestHelpers.MockValidationResult(errorsCollection, new ExecutionContextStub {
MaxDepth = maxDepth, CollectionForceKey = "*", RequiredError = new Error("Required")
});
if (expectException)
{
Assert.Throws <MaxDepthExceededException>(() => { result.ToListReport(); });
}
else
{
result.ToListReport();
}
}
public ValidateByObject()
{
Errors = new ErrorsCollection(this);
Validator.AddRules <ValidateByObject>(nameof(Name)).StringLength(7, 3);
Validator.AddRules <ValidateByObject>(nameof(Age)).Range(18, 200);
this.Validate();
}
public void ContainsSingleError_Should_ReturnTrue_When_SingleError()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError(new Error("test123"));
Assert.True(errorsCollection.ContainsSingleError());
}
public void ContainsSingleError_Should_ReturnFalse_When_MemberError()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("member", new Error("test123"));
Assert.False(errorsCollection.ContainsSingleError());
}
public void ToModelReport_Should_ReturnEmptyReport_When_NoErrors()
{
var errorsCollection = new ErrorsCollection();
var result = ResultsTestHelpers.MockValidationResult(errorsCollection);
Assert.Same(ModelReport.Empty, result.ToModelReport());
}
public void GetSingleError_Should_ReturnFalse_When_MemberError()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("member", new Error("test123"));
Assert.Throws <NoSingleErrorCollectionException>(() => { errorsCollection.GetSingleError(); });
}
public void Include_Should_Include_When_ContainsMultipleNestedLevels()
{
var nested11 = new ErrorsCollection();
nested11.AddError("arg11", new Error("val111"));
nested11.AddError("arg11", new Error("val112"));
var nested12 = new ErrorsCollection();
nested12.AddError("arg12", new Error("val121"));
nested12.AddError("arg12", new Error("val122"));
var nested1 = new ErrorsCollection();
nested1.AddError("arg1", new Error("val11"));
nested1.AddError("arg1", new Error("val12"));
nested1.AddError("arg1", nested11);
nested1.AddError("arg1", nested12);
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("foo", nested1);
var anotherNested12 = new ErrorsCollection();
anotherNested12.AddError("arg12", new Error("val122"));
anotherNested12.AddError("arg12", new Error("val123"));
var anotherNested13 = new ErrorsCollection();
anotherNested13.AddError("arg13", new Error("val131"));
anotherNested13.AddError("arg13", new Error("val132"));
var anotherNested1 = new ErrorsCollection();
anotherNested1.AddError("arg1", new Error("val12"));
anotherNested1.AddError("arg1", new Error("val13"));
anotherNested1.AddError("arg1", anotherNested12);
anotherNested1.AddError("arg1", anotherNested13);
var another = new ErrorsCollection();
another.AddError("foo", anotherNested1);
errorsCollection.Include(another);
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection, new[] { "foo" });
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection.Members["foo"], new[] { "arg1" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["foo"].Members["arg1"], new[] { "val11", "val12", "val12", "val13" });
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection.Members["foo"].Members["arg1"], new[] { "arg11", "arg12", "arg13" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["foo"].Members["arg1"].Members["arg11"], new[] { "val111", "val112" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["foo"].Members["arg1"].Members["arg12"], new[] { "val121", "val122", "val122", "val123" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["foo"].Members["arg1"].Members["arg13"], new[] { "val131", "val132" });
}
public static IErrorsCollection ExecuteCollectionMember <TModel, TItem>(IMemberValidator memberValidator, TModel model, IEnumerable <TItem> memberValue, IExecutionContext executionContext, ValidationStrategy validationStrategy, int depth)
where TModel : class
{
ErrorsCollection result = null;
if (validationStrategy == ValidationStrategy.Force)
{
var itemErrorsCollection = ExecuteMember(
memberValidator,
model,
default(TItem),
executionContext,
validationStrategy,
depth
);
result = new ErrorsCollection();
result.AddError(executionContext.CollectionForceKey, itemErrorsCollection);
}
else if (memberValue != null)
{
var items = memberValue.ToArray();
for (var i = 0; i < items.Length; i++)
{
var item = items.ElementAt(i);
var itemErrorsCollection = ExecuteMember(
memberValidator,
model,
item,
executionContext,
validationStrategy,
depth
);
if (itemErrorsCollection.IsEmpty)
{
continue;
}
if (result == null)
{
result = new ErrorsCollection();
}
result.AddError(i.ToString(), itemErrorsCollection);
if ((validationStrategy == ValidationStrategy.FailFast) && !result.IsEmpty)
{
break;
}
}
}
return(GetOrEmpty(result));
}
public void ToListReport_Should_ReturnEmptyReport_When_NoErrors()
{
var errorsCollection = new ErrorsCollection();
var result = ResultsTestHelpers.MockValidationResult(errorsCollection);
var report = result.ToListReport();
Assert.Empty(report);
}
public void AddError_Should_Add_SingleError()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError(new Error("test123"));
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection, new[] { "test123" });
Assert.False(errorsCollection.IsEmpty);
}
public void AddError_Should_AddNothing_When_EmptyCollection()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("test", new ErrorsCollection());
Assert.NotNull(errorsCollection.Members);
Assert.Empty(errorsCollection.Members);
Assert.True(errorsCollection.IsEmpty);
}
public void GetSingleError_Should_ReturnTrue_When_SingleError()
{
var errorsCollection = new ErrorsCollection();
var error = new Error("test123");
errorsCollection.AddError(error);
Assert.Same(error, errorsCollection.GetSingleError());
}
private RunContext(string source, string authorization, Cursor cursor, ExecuteFlags flags, IHttpExecutor semanticHttpExecutor, IHttpExecutor httpExecutor)
{
_source = source;
_flags = flags;
_semanticHttpExecutor = semanticHttpExecutor;
_httpExecutor = httpExecutor;
Authorization = authorization;
_editorCursor = cursor;
Errors = new ErrorsCollection();
}
public void Constructor_Should_Initialize_Internals()
{
var errorsCollection = new ErrorsCollection();
Assert.NotNull(errorsCollection);
Assert.NotNull(errorsCollection.Errors);
Assert.Empty(errorsCollection.Errors);
Assert.NotNull(errorsCollection.Members);
Assert.Empty(errorsCollection.Members);
Assert.True(errorsCollection.IsEmpty);
}
public Interpreter(Element root, Cursor cursor, string authorization, IHttpExecutor httpExecutor)
{
_program = root;
_scope = new Scope();
_visitStack = new Stack <QueryPhaseArgs>();
_httpExecutor = httpExecutor ?? new HttpExecutor(new HttpExecutorRaw(authorization));
_editorCursor = cursor;
_selectResult = new List <SelectTable>();
Errors = new ErrorsCollection();
}
public void AddError_Should_AddToMember_When_SingleErrors()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError("test", new Error("test123"));
ErrorsCollectionTestsHelpers.ExpectMembers(errorsCollection, new[] { "test" });
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection.Members["test"], new[] { "test123" });
Assert.False(errorsCollection.IsEmpty);
}
public void AddError_Should_Add_When_MultipleErrors()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError(new Error("test123"));
errorsCollection.AddError(new Error("test321"));
errorsCollection.AddError(new Error("foo"));
errorsCollection.AddError(new Error("bar"));
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection, new[] { "test123", "test321", "foo", "bar" });
Assert.False(errorsCollection.IsEmpty);
}
public void AddError_Should_Add_WithDuplicates()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError(new Error("test123"));
errorsCollection.AddError(new Error("test123"));
errorsCollection.AddError(new Error("foo"));
errorsCollection.AddError(new Error("foo"));
ErrorsCollectionTestsHelpers.ExpectErrors(errorsCollection, new[] { "test123", "test123", "foo", "foo" });
Assert.False(errorsCollection.IsEmpty);
}
public void ToModelReport_Should_Generate_RootMessages()
{
var draft = new ErrorsCollection();
draft.AddError(new Error("test123"));
draft.AddError(new Error("test321"));
draft.AddError(new Error("foo"));
draft.AddError(new Error("bar"));
var report = ResultsTestHelpers.MockValidationResult(draft).ToModelReport() as ModelReportErrorsList;
ExpectMessagesInList(report, new[] { "test123", "test321", "foo", "bar" });
}
public void ToListReport_Should_Generate_RootMessages()
{
var errorsCollection = new ErrorsCollection();
errorsCollection.AddError(new Error("test123"));
errorsCollection.AddError(new Error("test321"));
errorsCollection.AddError(new Error("foo"));
errorsCollection.AddError(new Error("bar"));
var report = ResultsTestHelpers.MockValidationResult(errorsCollection).ToListReport();
ExpectMessagesInReport(report, "", new[] { "test123", "test321", "foo", "bar" });
}
///<summary>
/// Run validation
///</summary>
///<returns></returns>
public bool Validate()
{
_Errors = new StringBuilder();
_CurrentList = new ErrorsCollection();
foreach (var i in Course.Organization.Items)
{
if (i.PageType == PageType.Question)
{
var p = HtmlPageBase.GetPage(i);
if (p == null)
{
using (var page = new HtmlPage { Parent = new Form() })
{
page.Name = i.Title;
page.SetPageItem(i);
page.ParseHtmlFile(i.PageHref, (htmlPage, control) => { });
page.ReValidate();
_CurrentList.AddRange(page.Errors);
}
}
else
{
p.ReValidate();
_CurrentList.AddRange(p.Errors);
}
foreach (var error in _CurrentList)
{
if (_Errors.Length > 0)
{
_Errors.AppendLine();
}
_Errors.Append(i.GetFullPath());
if (error.Source != i)
{
_Errors.Append("/" + error.Source.Title);
}
_Errors.Append(": ");
_Errors.Append(error.Message);
}
}
foreach (string error in i.Errors)
{
this._Errors.AppendLine(error);
}
}
return _Errors.Length == 0;
}
