public void CreatePropertyContainer_MultiplePropertiesWithNullCheck()
{
// Arrange
var properties = new[]
{
new NamedPropertyExpression(name: Expression.Constant("Prop1"), value: Expression.Constant(1))
{
NullCheck = Expression.Constant(true)
},
new NamedPropertyExpression(name: Expression.Constant("Prop2"), value: Expression.Constant(2))
{
NullCheck = Expression.Constant(false)
},
};
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
PropertyContainer container = ToContainer(containerExpression);
var dict = container.ToDictionary(new IdentityPropertyMapper());
Assert.Null(dict["Prop1"]);
Assert.Equal(2, dict["Prop2"]);
}
private Expression BuildPropertyContainer(IEdmEntityType elementType, Expression source,
Dictionary <IEdmNavigationProperty, ExpandedNavigationSelectItem> propertiesToExpand,
ISet <IEdmStructuralProperty> propertiesToInclude, ISet <IEdmStructuralProperty> autoSelectedProperties)
{
IList <NamedPropertyExpression> includedProperties = new List <NamedPropertyExpression>();
foreach (KeyValuePair <IEdmNavigationProperty, ExpandedNavigationSelectItem> kvp in propertiesToExpand)
{
IEdmNavigationProperty propertyToExpand = kvp.Key;
ExpandedNavigationSelectItem expandItem = kvp.Value;
SelectExpandClause projection = expandItem.SelectAndExpand;
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToExpand, source);
Expression propertyValue = CreatePropertyValueExpressionWithFilter(elementType, propertyToExpand, source,
expandItem.FilterOption);
Expression nullCheck = Expression.Equal(propertyValue, Expression.Constant(null));
// projection can be null if the expanded navigation property is not further projected or expanded.
if (projection != null)
{
propertyValue = ProjectAsWrapper(propertyValue, projection, propertyToExpand.ToEntityType());
}
NamedPropertyExpression propertyExpression = new NamedPropertyExpression(propertyName, propertyValue);
if (projection != null)
{
if (!propertyToExpand.Type.IsCollection())
{
propertyExpression.NullCheck = nullCheck;
}
else if (_settings.PageSize != null)
{
propertyExpression.PageSize = _settings.PageSize.Value;
}
}
includedProperties.Add(propertyExpression);
}
foreach (IEdmStructuralProperty propertyToInclude in propertiesToInclude)
{
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToInclude, source);
Expression propertyValue = CreatePropertyValueExpression(elementType, propertyToInclude, source);
includedProperties.Add(new NamedPropertyExpression(propertyName, propertyValue));
}
foreach (IEdmStructuralProperty propertyToInclude in autoSelectedProperties)
{
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToInclude, source);
Expression propertyValue = CreatePropertyValueExpression(elementType, propertyToInclude, source);
includedProperties.Add(new NamedPropertyExpression(propertyName, propertyValue)
{
AutoSelected = true
});
}
// create a property container that holds all these property names and values.
return(PropertyContainer.CreatePropertyContainer(includedProperties));
}
public void CreatePropertyContainer_CreatesPropertyContainer_WithVariousNumberOfProperties(int count)
{
// Arrange
IList <NamedPropertyExpression> properties =
Enumerable.Range(0, count)
.Select(i => new NamedPropertyExpression(Expression.Constant(i.ToString()), Expression.Constant(i)))
.ToList();
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
Dictionary <string, object> dictionary = ToContainer(containerExpression).ToDictionary(new IdentityPropertyMapper(), includeAutoSelected: true);
Assert.Equal(Enumerable.Range(0, count).ToDictionary(i => i.ToString(), i => (object)i).OrderBy(kvp => kvp.Key), dictionary.OrderBy(kvp => kvp.Key));
}
public void CreatePropertyContainer_WithNullPropertyName_DoesntIncludeTheProperty()
{
// Arrange
Expression propertyName = Expression.Constant(null, typeof(string));
Expression propertyValue = Expression.Constant(new TestEntity());
NamedPropertyExpression property = new NamedPropertyExpression(propertyName, propertyValue);
var properties = new[] { property, property };
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
PropertyContainer container = ToContainer(containerExpression);
Assert.Empty(container.ToDictionary(new IdentityPropertyMapper(), includeAutoSelected: true));
}
public void ToDictionary_Throws_IfMappingFunctionReturns_NullOrEmpty(string mappedName)
{
// Arrange
IList <NamedPropertyExpression> properties = new NamedPropertyExpression[]
{
new NamedPropertyExpression(name: Expression.Constant("PropA"), value: Expression.Constant(3))
};
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
PropertyContainer container = ToContainer(containerExpression);
Mock <IPropertyMapper> mapperMock = new Mock <IPropertyMapper>();
mapperMock.Setup(m => m.MapProperty("PropA")).Returns(mappedName);
// Act & Assert
Assert.Throws <InvalidOperationException>(() =>
container.ToDictionary(mapperMock.Object), "The key mapping for the property 'PropA' can't be null or empty.");
}
public void CreatePropertyContainer_CreatesMemberInitExpression()
{
// Arrange
Expression propertyName = Expression.Constant("PropertyName");
Mock <Expression> propertyValue = new Mock <Expression>();
propertyValue.Setup(p => p.Type).Returns(typeof(TestEntity));
var properties = new[] { new NamedPropertyExpression(propertyName, propertyValue.Object) };
// Act
Expression container = PropertyContainer.CreatePropertyContainer(properties);
// Assert
Assert.Equal(ExpressionType.MemberInit, container.NodeType);
MemberInitExpression memberInit = container as MemberInitExpression;
Assert.True(typeof(PropertyContainer).IsAssignableFrom(memberInit.NewExpression.Type));
}
public void CreatePropertyContainer_WithNullCheckTrue_PropertyIsNull()
{
// Arrange
string propertyName = "PropertyName";
Expression propertyNameExpression = Expression.Constant(propertyName);
Expression propertyValueExpression = Expression.Constant(42);
Expression nullCheckExpression = Expression.Constant(true);
var properties = new[] { new NamedPropertyExpression(propertyNameExpression, propertyValueExpression)
{
NullCheck = nullCheckExpression
} };
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
PropertyContainer container = ToContainer(containerExpression);
var dict = container.ToDictionary(new IdentityPropertyMapper());
Assert.Contains(propertyName, dict.Keys);
Assert.Null(dict[propertyName]);
}
public void CreatePropertyContainer_AutoSelectedProperty()
{
// Arrange
Expression propertyName = Expression.Constant("PropertyName");
Expression propertyValue = Expression.Constant(42);
var properties = new[] { new NamedPropertyExpression(propertyName, propertyValue)
{
AutoSelected = true
} };
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
PropertyContainer container = ToContainer(containerExpression);
var dict = container.ToDictionary(new IdentityPropertyMapper(), includeAutoSelected: true);
Assert.Contains("PropertyName", dict.Keys);
dict = container.ToDictionary(new IdentityPropertyMapper(), includeAutoSelected: false);
Assert.DoesNotContain("PropertyName", dict.Keys);
}
public void CreatePropertyContainer_PageSize()
{
// Arrange
int pageSize = 5;
Expression propertyName = Expression.Constant("PropertyName");
Expression propertyValue = Expression.Constant(Enumerable.Range(0, 10));
var properties = new[] { new NamedPropertyExpression(propertyName, propertyValue)
{
PageSize = pageSize
} };
// Act
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
// Assert
PropertyContainer container = ToContainer(containerExpression);
var result = container.ToDictionary(new IdentityPropertyMapper())["PropertyName"];
var truncatedCollection = Assert.IsType <TruncatedCollection <int> >(result);
Assert.True(truncatedCollection.IsTruncated);
Assert.Equal(pageSize, truncatedCollection.PageSize);
Assert.Equal(Enumerable.Range(0, pageSize), truncatedCollection);
}
public void ToDictionary_AppliesMappingToAllProperties()
{
// Arrange
IList <NamedPropertyExpression> properties = new NamedPropertyExpression[]
{
new NamedPropertyExpression(name: Expression.Constant("PropA"), value: Expression.Constant(3)),
new NamedPropertyExpression(name: Expression.Constant("PropB"), value: Expression.Constant(6))
};
Expression containerExpression = PropertyContainer.CreatePropertyContainer(properties);
PropertyContainer container = ToContainer(containerExpression);
Mock <IPropertyMapper> mapperMock = new Mock <IPropertyMapper>();
mapperMock.Setup(m => m.MapProperty("PropA")).Returns("PropertyA");
mapperMock.Setup(m => m.MapProperty("PropB")).Returns("PropB");
//Act
IDictionary <string, object> result = container.ToDictionary(mapperMock.Object);
//Assert
Assert.NotNull(result);
Assert.True(result.ContainsKey("PropertyA"));
Assert.True(result.ContainsKey("PropB"));
}
private Expression BuildPropertyContainer(IEdmEntityType elementType, Expression source,
Dictionary <IEdmNavigationProperty, ExpandedNavigationSelectItem> propertiesToExpand,
ISet <IEdmStructuralProperty> propertiesToInclude, ISet <IEdmStructuralProperty> autoSelectedProperties, bool isSelectingOpenTypeSegments)
{
IList <NamedPropertyExpression> includedProperties = new List <NamedPropertyExpression>();
foreach (KeyValuePair <IEdmNavigationProperty, ExpandedNavigationSelectItem> kvp in propertiesToExpand)
{
IEdmNavigationProperty propertyToExpand = kvp.Key;
ExpandedNavigationSelectItem expandItem = kvp.Value;
SelectExpandClause projection = expandItem.SelectAndExpand;
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToExpand, source);
Expression propertyValue = CreatePropertyValueExpressionWithFilter(elementType, propertyToExpand, source,
expandItem.FilterOption);
Expression nullCheck = Expression.Equal(propertyValue, Expression.Constant(null));
Expression countExpression = CreateTotalCountExpression(propertyValue, expandItem);
// projection can be null if the expanded navigation property is not further projected or expanded.
if (projection != null)
{
propertyValue = ProjectAsWrapper(propertyValue, projection, propertyToExpand.ToEntityType(), expandItem.NavigationSource as IEdmEntitySet);
}
NamedPropertyExpression propertyExpression = new NamedPropertyExpression(propertyName, propertyValue);
if (projection != null)
{
if (!propertyToExpand.Type.IsCollection())
{
propertyExpression.NullCheck = nullCheck;
}
else if (_settings.PageSize != null)
{
propertyExpression.PageSize = _settings.PageSize.Value;
}
propertyExpression.TotalCount = countExpression;
propertyExpression.CountOption = expandItem.CountOption;
}
includedProperties.Add(propertyExpression);
}
foreach (IEdmStructuralProperty propertyToInclude in propertiesToInclude)
{
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToInclude, source);
Expression propertyValue = CreatePropertyValueExpression(elementType, propertyToInclude, source);
includedProperties.Add(new NamedPropertyExpression(propertyName, propertyValue));
}
foreach (IEdmStructuralProperty propertyToInclude in autoSelectedProperties)
{
Expression propertyName = CreatePropertyNameExpression(elementType, propertyToInclude, source);
Expression propertyValue = CreatePropertyValueExpression(elementType, propertyToInclude, source);
includedProperties.Add(new NamedPropertyExpression(propertyName, propertyValue)
{
AutoSelected = true
});
}
if (isSelectingOpenTypeSegments)
{
var dynamicPropertyDictionary = EdmLibHelpers.GetDynamicPropertyDictionary(elementType, _model);
Expression propertyName = Expression.Constant(dynamicPropertyDictionary.Name);
Expression propertyValue = Expression.Property(source, dynamicPropertyDictionary.Name);
Expression nullablePropertyValue = ExpressionHelpers.ToNullable(propertyValue);
if (_settings.HandleNullPropagation == HandleNullPropagationOption.True)
{
// source == null ? null : propertyValue
propertyValue = Expression.Condition(
test: Expression.Equal(source, Expression.Constant(value: null)),
ifTrue: Expression.Constant(value: null, type: propertyValue.Type.ToNullable()),
ifFalse: nullablePropertyValue);
}
else
{
propertyValue = nullablePropertyValue;
}
includedProperties.Add(new NamedPropertyExpression(propertyName, propertyValue));
}
// create a property container that holds all these property names and values.
return(PropertyContainer.CreatePropertyContainer(includedProperties));
}