public void DPathProcessor_WhenProductFounded_ShouldReturnArrayWithSingleElement(string expression, Article product)
{
// Exercise system
var actualResult = DPathProcessor.Process(expression, product);
// Verify outcome
Assert.Single(actualResult);
}
public void TestEvaluatorRootFilter()
{
var xaml = File.ReadAllText("TestData\\ReferenceDto.xaml");
var productDto = (Article)XamlConfigurationParser.CreateFrom(xaml);
var res = DPathProcessor.Process("[Type='305']", productDto);
Assert.IsTrue(res.Length > 0);
}
public void TestEvaluatorExtensionField()
{
var xaml = File.ReadAllText("TestData\\ReferenceDto.xaml");
var productDto = (Article)XamlConfigurationParser.CreateFrom(xaml);
var res = DPathProcessor.Process("MarketingProduct[ProductType='289']", productDto);
Assert.IsTrue(res.Length > 0);
}
protected override object GetValueInternal(DependencyProperty prop, BindingExression be, object context)
{
if (!(context is Article))
{
throw new ArgumentException("context must be Article");
}
return(DPathProcessor.Process(be.Expression, (Article)context).Select(mop => mop.ModelObject).ToArray());
}
public void DPathProcessor_WhenProductFounded_ShouldReturnArrayWithMultipleElements(string expression, Article product, int expectedResult)
{
// Fixture setup
// Exercise system
var actualResult = DPathProcessor.Process(expression, product);
// Verify outcome
Assert.Equal(expectedResult, actualResult.Length);
}
public void DPathProcessor_WithDifferentPathExpressions_ShouldParseCorrectly(string expression, DPathArticleData[] expectedResult)
{
// Fixture setup
// Exercise system
var actualResult = DPathProcessor.VerifyAndParseExpression(expression).ToArray();
// Verify outcome
actualResult.Should().BeEquivalentTo(expectedResult);
}
public void DPathProcessor_GivenWrongExpression_ShouldThrowException(string expression, Article product)
{
// Fixture setup
// Exercise system
Action actionResult = () => DPathProcessor.Process(expression, product);
// Verify outcome
Assert.Throws <Exception>(actionResult);
}
public void DPathProcessor_WhenProductNotFounded_ShouldReturnEmptyArray(string expression, Article product)
{
// Fixture setup
var expectedResult = Enumerable.Empty <ModelObjectWithParent>().ToArray();
// Exercise system
var actualResult = DPathProcessor.Process(expression, product);
// Verify outcome
Assert.Equal(expectedResult, actualResult);
}
public Field GetFieldByPath(string path, Content definition, out bool hasFilter, out Content parent)
{
var articleData = DPathProcessor.VerifyAndParseExpression(path).ToList();
hasFilter = articleData.Any(ad => ad.FiltersData.Any());
parent = definition;
Field currentField = null;
foreach (var fieldName in articleData.Select(ad => ad.FieldName))
{
if (currentField != null)
{
var currentEntityField = currentField as EntityField;
if (currentEntityField == null)
{
throw new Exception("Schema generator requires virtual field to relate to EntityField type or its descendant");
}
parent = currentEntityField.Content;
}
var nonVirtualFields = parent.Fields.Where(x => !(x is BaseVirtualField)).ToArray();
if (nonVirtualFields.All(x => x.FieldName != fieldName) && parent.LoadAllPlainFields)
{
var allPlainFields = _fieldService.List(parent.ContentId).Where(x => x.RelationType == RelationType.None);
currentField = new PlainField
{
FieldId = allPlainFields.Single(x => x.Name == fieldName).Id,
FieldName = fieldName
};
}
else
{
currentField = nonVirtualFields.Single(x => x.FieldName == fieldName);
}
}
return(currentField);
}
public RemoteValidationResult Validate(RemoteValidationContext context, RemoteValidationResult result)
{
var filterDefinition = context.Definitions.FirstOrDefault(x => x.Alias == FieldFilter);
if (filterDefinition == null)
{
var message = new ActionTaskResultMessage()
{
ResourceClass = ValidationHelper.ResourceClass,
ResourceName = nameof(RemoteValidationMessages.MissingParam),
Parameters = new object[] { FieldFilter }
};
result.AddErrorMessage(ValidationHelper.ToString(context, message));
}
else
{
var filter = context.ProvideValueExact <string>(filterDefinition);
if (string.IsNullOrEmpty(filter))
{
return(result);
}
var normalizedFilter = DPathProcessor.NormalizeExpression(filter);
if (!DPathProcessor.IsExpressionValid(normalizedFilter))
{
var message = new ActionTaskResultMessage()
{
ResourceClass = ValidationHelper.ResourceClass,
ResourceName = nameof(RemoteValidationMessages.InvalidFilter),
Parameters = new object[] { normalizedFilter }
};
result.AddModelError(filterDefinition.PropertyName, ValidationHelper.ToString(context, message));
}
}
return(result);
}
private static bool Match(string filter, Article product)
{
return(string.IsNullOrEmpty(filter) || DPathProcessor.Process(filter, product).Any());
}
