public void ResolveMemberAccess_OnSqlTableReferenceExpression()
{
var expression = new SqlTableReferenceExpression(SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
var memberInfo = typeof(Cook).GetProperty("FirstName");
MemberAccessResolver.ResolveMemberAccess(expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
}
public void ResolveMemberAccess_OnSqlEntityConstantExpression()
{
var expression = new SqlEntityConstantExpression(typeof(Cook), new Cook(), Expression.Constant(14));
var memberInfo = typeof(Cook).GetProperty("FirstName");
MemberAccessResolver.ResolveMemberAccess(expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
}
public void ResolveMemberAccess_OnEntity_WithCollectionMember()
{
var memberInfo = typeof(Cook).GetProperty("Courses");
var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook), null, "c");
MemberAccessResolver.ResolveMemberAccess(sqlEntityExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
}
public void ResolveMemberAccess_OnEntityRefMemberExpression_NoOptimization()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var entityRefMemberExpression = SqlStatementModelObjectMother.CreateSqlEntityRefMemberExpression();
_resolverMock
.Stub(mock => mock.TryResolveOptimizedMemberExpression(entityRefMemberExpression, memberInfo))
.Return(null);
var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
_stageMock
.Expect(
mock =>
mock.ResolveEntityRefMemberExpression(
Arg.Is(entityRefMemberExpression),
Arg <UnresolvedJoinInfo> .Matches(j =>
j.OriginatingEntity == entityRefMemberExpression.OriginatingEntity &&
j.MemberInfo == entityRefMemberExpression.MemberInfo &&
j.Cardinality == JoinCardinality.One),
Arg.Is(_mappingResolutionContext)))
.Return(fakeEntityExpression);
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(fakeEntityExpression, memberInfo))
.Return(fakeResult);
var result = MemberAccessResolver.ResolveMemberAccess(entityRefMemberExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void ResolveMemberAccess_OnUnsupportedExpression()
{
var operand = new SqlColumnDefinitionExpression(typeof(int), "c", "ID", false);
var convertExpression = Expression.And(operand, operand);
var memberInfo = typeof(Chef).GetProperty("LetterOfRecommendation");
MemberAccessResolver.ResolveMemberAccess(convertExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
}
public void ResolveMemberAccess_OnGroupingSelectExpression()
{
var expression = SqlStatementModelObjectMother.CreateSqlGroupingSelectExpression();
var memberInfo = typeof(IGrouping <string, string>).GetProperty("Key");
var result = MemberAccessResolver.ResolveMemberAccess(expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
Assert.That(result, Is.SameAs(expression.KeyExpression));
}
public void ResolveMemberAccess_OnGroupingSelectExpression_StripsNames()
{
var expression = new SqlGroupingSelectExpression(
new NamedExpression("k", Expression.Constant("key")),
new NamedExpression("e", Expression.Constant("element")));
var memberInfo = typeof(IGrouping <string, string>).GetProperty("Key");
var result = MemberAccessResolver.ResolveMemberAccess(expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
Assert.That(result, Is.SameAs(((NamedExpression)expression.KeyExpression).Expression));
}
public void ResolveMemberAccess_MemberAppliedToConstant()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var expression = Expression.Constant(new Cook());
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveConstantExpression(expression))
.Return(fakeResult);
_resolverMock.Replay();
MemberAccessResolver.ResolveMemberAccess(expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
}
public void ResolveMemberAccess_OnNewExpression_NoMembers()
{
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
var newExpression = Expression.New(
constructorInfo,
new[] { new NamedExpression("value", new SqlLiteralExpression(1)), new NamedExpression("value", new SqlLiteralExpression(2)) });
MemberAccessResolver.ResolveMemberAccess(
newExpression,
typeof(TypeForNewExpression).GetField("C"),
_resolverMock,
_stageMock,
_mappingResolutionContext);
}
public void ResolveMemberAccess_OnColumnExpression()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var constantExpression = Expression.Constant("test");
var columnExpression = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(columnExpression, memberInfo))
.Return(constantExpression);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(columnExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(constantExpression));
}
void SetDefaultAccess(Member member, CollectionMapping mapping)
{
var resolvedAccess = MemberAccessResolver.Resolve(member);
if (resolvedAccess != Access.Property && resolvedAccess != Access.Unset)
{
// if it's a property or unset then we'll just let NH deal with it, otherwise
// set the access to be whatever we determined it might be
mapping.Set(x => x.Access, Layer.Defaults, resolvedAccess.ToString());
}
if (member.IsProperty && !member.CanWrite)
{
mapping.Set(x => x.Access, Layer.Defaults, cfg.GetAccessStrategyForReadOnlyProperty(member).ToString());
}
}
public void ResolveMemberAccess_OnEntity()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var sqlEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(sqlEntityExpression, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(sqlEntityExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void ResolveMemberAccess_OnUnaryExpression_Convert()
{
var operand = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var convertExpression = Expression.Convert(Expression.Convert(operand, typeof(Chef)), typeof(Chef));
var memberInfo = typeof(Chef).GetProperty("LetterOfRecommendation");
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(operand, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(convertExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void ResolveMemberAccess_OnNewExpression_FieldInfo()
{
var constructorInfo = TypeForNewExpression.GetConstructor(typeof(int), typeof(int));
var newExpression = Expression.New(
constructorInfo,
new[] { new NamedExpression("value", new SqlLiteralExpression(1)), new NamedExpression("value", new SqlLiteralExpression(2)) },
typeof(TypeForNewExpression).GetField("C"), typeof(TypeForNewExpression).GetMethod("get_B"));
var result = MemberAccessResolver.ResolveMemberAccess(
newExpression,
typeof(TypeForNewExpression).GetField("C"),
_resolverMock,
_stageMock,
_mappingResolutionContext);
Assert.That(result, Is.SameAs(((NamedExpression)newExpression.Arguments[0]).Expression));
}
public void ResolveMemberAccess_OnNamedExpression()
{
var operand = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var namedExpression = new NamedExpression("two", new NamedExpression("one", operand));
var memberInfo = typeof(Cook).GetProperty("FirstName");
var fakeResult = Expression.Constant(0);
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(operand, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(namedExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void ResolveMemberAccess_OnEntityRefMemberExpression_WithSuccessfulOptimization()
{
var memberInfo = typeof(Cook).GetProperty("Substitution");
var entityRefMemberExpression = SqlStatementModelObjectMother.CreateSqlEntityRefMemberExpression();
var fakeResolvedExpression = ExpressionHelper.CreateExpression();
_resolverMock
.Expect(mock => mock.TryResolveOptimizedMemberExpression(entityRefMemberExpression, memberInfo))
.Return(fakeResolvedExpression);
var result = MemberAccessResolver.ResolveMemberAccess(entityRefMemberExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
_stageMock.AssertWasNotCalled(
mock => mock.ResolveEntityRefMemberExpression(
Arg <SqlEntityRefMemberExpression> .Is.Anything, Arg <IJoinInfo> .Is.Anything, Arg <IMappingResolutionContext> .Is.Anything));
Assert.That(result, Is.SameAs(fakeResolvedExpression));
}
public void ResolveMemberAccess_OnNestedNamedConvertExpressions()
{
var operand = new SqlColumnDefinitionExpression(typeof(Cook), "c", "ID", false);
var innerMostNamedExpression = new NamedExpression("inner", operand);
var innerConvertExpression = Expression.Convert(innerMostNamedExpression, typeof(Chef));
var outerNamedExpression = new NamedExpression("outer", innerConvertExpression);
var outerMostConvertExpression = Expression.Convert(outerNamedExpression, typeof(Cook));
var memberInfo = typeof(Cook).GetProperty("FirstName");
var fakeResult = Expression.Constant("empty");
_resolverMock
.Expect(mock => mock.ResolveMemberExpression(operand, memberInfo))
.Return(fakeResult);
_resolverMock.Replay();
var result = MemberAccessResolver.ResolveMemberAccess(outerMostConvertExpression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void AutoProperty()
{
MemberAccessResolver.Resolve(ReflectionExtensions.ToMember <Example, string>(x => x.AutoProperty))
.ShouldEqual(FluentNHibernate.Mapping.Access.Property);
}
public virtual Access GetAccessStrategyForReadOnlyProperty(Member member)
{
return(MemberAccessResolver.Resolve(member));
}
public void PropertyNoSetter()
{
MemberAccessResolver.Resolve(ReflectionExtensions.ToMember <Example, string>(x => x.PropertyNoSetter))
.ShouldEqual(FluentNHibernate.Mapping.Access.ReadOnlyPropertyThroughCamelCaseField());
}
public void Field()
{
MemberAccessResolver.Resolve(ReflectionExtensions.ToMember <Example, string>(x => x.Field))
.ShouldEqual(FluentNHibernate.Mapping.Access.Field);
}
public void Method()
{
MemberAccessResolver.Resolve(ReflectionExtensions.ToMember <Example, IEnumerable <Example> >(x => x.GetViaMethod()))
.ShouldEqual(FluentNHibernate.Mapping.Access.Field);
}
public void AutoPropertyPrivateSetter()
{
MemberAccessResolver.Resolve(ReflectionExtensions.ToMember <Example, string>(x => x.AutoPropertyPrivateSetter))
.ShouldEqual(FluentNHibernate.Mapping.Access.BackField);
}
