public void Transform_AddDays()
{
var value = new CustomExpression(typeof(double));
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(() => DateTime.Now.AddDays(0.0));
var expression = Expression.Call(_dateTimeInstance, methodInfo, value);
var result = _transformer.Transform(expression);
var expectedResult = new SqlFunctionExpression(
typeof(DateTime),
"DATEADD",
new SqlCustomTextExpression("millisecond", typeof(string)),
Expression.Modulo(
new SqlConvertExpression(typeof(long), Expression.Multiply(value, new SqlLiteralExpression(86400000.0))),
new SqlLiteralExpression(86400000L)),
new SqlFunctionExpression
(
typeof(DateTime),
"DATEADD",
new SqlCustomTextExpression("day", typeof(string)),
Expression.Divide(
new SqlConvertExpression(typeof(long), Expression.Multiply(value, new SqlLiteralExpression(86400000.0))),
new SqlLiteralExpression(86400000L)),
_dateTimeInstance));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void VisitMethodCallExpression_NoSetOperations()
{
var visitor = CreateVisitor(SetOperationsMode.StatementIsNotSetCombined);
Assert.That(visitor.ColumnPosition, Is.EqualTo(0));
var methodCallExpression = Expression.Call(
_namedIntExpression,
MemberInfoFromExpressionUtility.GetMethod(() => 0.ToString ("")),
new Expression[] { _namedNameColumnExpression });
visitor.VisitMethodCall(methodCallExpression);
Assert.That(visitor.ColumnPosition, Is.EqualTo(2));
var expectedRowParameter = _commandBuilder.InMemoryProjectionRowParameter;
// Constants are used as is in the projection, whereas columns are taken from the SQL result
var expectedProjectionForInstanceExpression = Expression.Constant(0);
var expectedProjectionForArgumentExpression = GetExpectedProjectionForNamedExpression(expectedRowParameter, "SomeName", 1, typeof(string));
var expectedProjection = Expression.Call(
expectedProjectionForInstanceExpression,
methodCallExpression.Method,
new Expression[] { expectedProjectionForArgumentExpression });
Assert.That(
_commandBuilder.GetCommandText(),
Is.EqualTo("NULL AS [test],[c].[Name] AS [SomeName]"));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedProjection, _commandBuilder.GetInMemoryProjectionBody());
}
public void NormalMethod_ReturnsNull()
{
var method = MemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
var result = method.GetRelatedEventInfo();
Assert.That(result, Is.Null);
}
public void ConvertToRuntimeProperty_WithPropertyAdapter_ReturnsRuntimeType()
{
var expectedProperty = MemberInfoFromExpressionUtility.GetProperty((TheType t) => t.TheProperty);
IPropertyInformation propertyInformation = PropertyInfoAdapter.Create(expectedProperty);
Assert.That(propertyInformation.ConvertToRuntimePropertyInfo(), Is.SameAs(expectedProperty));
}
public Expression <Func <object, object> > GetPropertyAccessExpression(Type validatedType)
{
ArgumentUtility.CheckNotNull("validatedType", validatedType);
var parameterExpression = Expression.Parameter(typeof(object), "t");
// object o => UsePersistentProperty ((DomainObject)o, _interfaceProperty) ? (object) (TheType o).TheProperty : nonEmptyObject;
var usePersistentPropertyMethod = MemberInfoFromExpressionUtility.GetMethod(() => UsePersistentProperty(null, null));
var conditionExpression = Expression.Call(
usePersistentPropertyMethod,
Expression.Convert(parameterExpression, typeof(DomainObject)),
Expression.Constant(_implementationProperty, typeof(PropertyInfo)));
// object o => (object) (TheType o).TheProperty
var domainObjectPropertyAccessExpression = Expression.Convert(
Expression.MakeMemberAccess(
Expression.Convert(parameterExpression, validatedType),
_interfaceProperty),
typeof(object));
var nonEmptyDummyValue = ReflectionUtility.IsObjectList(_implementationProperty.PropertyType)
? FakeDomainObject.CollectionValue
: (object)FakeDomainObject.SingleValue;
var nonEmptyDummyValueExpression = Expression.Constant(nonEmptyDummyValue, typeof(object));
return(Expression.Lambda <Func <object, object> > (
Expression.Condition(conditionExpression, domainObjectPropertyAccessExpression, nonEmptyDummyValueExpression),
parameterExpression));
}
public void ResolveIDPropertyViaForeignKey_WithFullObjectID_ResolvesToCompound()
{
var propertyDefinition = CreatePropertyDefinitionAndAssociateWithClass(_classDefinition, "Customer", "Customer");
var objectIDStorageProperty = ObjectIDStoragePropertyDefinitionObjectMother.Create(
"CustomerID",
"CustomerClassID",
StorageTypeInformationObjectMother.CreateUniqueIdentifierStorageTypeInformation(),
StorageTypeInformationObjectMother.CreateVarchar100StorageTypeInformation());
var foreignKeyEndPointDefinition = new RelationEndPointDefinition(propertyDefinition, false);
_rdbmsPersistenceModelProviderStub
.Stub(stub => stub.GetStoragePropertyDefinition(foreignKeyEndPointDefinition.PropertyDefinition))
.Return(objectIDStorageProperty);
var originatingEntity = CreateEntityDefinition(typeof(Order), "o");
var result = _storageSpecificExpressionResolver.ResolveIDPropertyViaForeignKey(originatingEntity, foreignKeyEndPointDefinition);
var expected = Expression.New(
MemberInfoFromExpressionUtility.GetConstructor(() => new ObjectID("classID", "value")),
new[]
{
new NamedExpression("ClassID", originatingEntity.GetColumn(typeof(string), "CustomerClassID", false)),
new NamedExpression("Value", Expression.Convert(originatingEntity.GetColumn(typeof(Guid), "CustomerID", false), typeof(object)))
},
new[] { typeof(ObjectID).GetProperty("ClassID"), typeof(ObjectID).GetProperty("Value") });
SqlExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public void ResoveIDProperty()
{
var entityExpression = CreateEntityDefinition(typeof(Order), "o");
var entityDefinition = TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition, new EntityNameDefinition(null, "Test"));
_rdbmsPersistenceModelProviderStub
.Stub(stub => stub.GetEntityDefinition(_classDefinition))
.Return(entityDefinition);
var result = _storageSpecificExpressionResolver.ResolveIDProperty(entityExpression, _classDefinition);
var ctor = MemberInfoFromExpressionUtility.GetConstructor(() => new ObjectID("ClassID", "value"));
SqlExpressionTreeComparer.CheckAreEqualTrees(
Expression.New(
ctor,
new[]
{
new NamedExpression("ClassID", new SqlColumnDefinitionExpression(typeof(string), "o", "ClassID", false)),
new NamedExpression("Value", Expression.Convert(new SqlColumnDefinitionExpression(typeof(Guid), "o", "ID", true), typeof(object)))
},
new[]
{
typeof(ObjectID).GetProperty("ClassID"),
typeof(ObjectID).GetProperty("Value")
}),
result);
}
public void VisitMethodCallExpression_NoSetOperations_WithoutObject()
{
var visitor = CreateVisitor(SetOperationsMode.StatementIsNotSetCombined);
Assert.That(visitor.ColumnPosition, Is.EqualTo(0));
var methodCallExpression = Expression.Call(
MemberInfoFromExpressionUtility.GetMethod(() => int.Parse("")),
new Expression[] { _namedNameColumnExpression });
visitor.VisitMethodCall(methodCallExpression);
Assert.That(visitor.ColumnPosition, Is.EqualTo(1));
var expectedRowParameter = _commandBuilder.InMemoryProjectionRowParameter;
var expectedProjectionForArgumentExpression = GetExpectedProjectionForNamedExpression(expectedRowParameter, "SomeName", 0, typeof(string));
var expectedProjection = Expression.Call(
methodCallExpression.Method,
new Expression[] { expectedProjectionForArgumentExpression });
Assert.That(
_commandBuilder.GetCommandText(),
Is.EqualTo("[c].[Name] AS [SomeName]"));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedProjection, _commandBuilder.GetInMemoryProjectionBody());
}
public void GetField_Instance()
{
var member = MemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.InstanceField);
var expected = typeof(DomainType).GetField("InstanceField");
Assert.That(member, Is.EqualTo(expected));
}
public void FuncWithArgs()
{
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(((DomainType obj) => obj.MixedMethod("a", 1)));
var result = methodInfo.GetDelegateType();
Assert.That(result, Is.EqualTo(typeof(Func <string, int, object>)));
}
public void Func()
{
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(((DomainType obj) => obj.ReturnMethod()));
var result = methodInfo.GetDelegateType();
Assert.That(result, Is.EqualTo(typeof(Func <string>)));
}
public void ActionWithArgs()
{
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(((DomainType obj) => obj.ArgMethod("a")));
var result = methodInfo.GetDelegateType();
Assert.That(result, Is.EqualTo(typeof(Action <string>)));
}
public void Action()
{
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(((DomainType obj) => obj.SimpleMethod()));
var result = methodInfo.GetDelegateType();
Assert.That(result, Is.EqualTo(typeof(Action)));
}
public void UserDefinedMethod()
{
var methodInfo = MemberInfoFromExpressionUtility.GetMethod(((DomainType obj) => obj.Method()));
var result = methodInfo.IsCompilerGenerated();
Assert.That(result, Is.False);
}
public void GetMethod_StaticVoid()
{
var member = MemberInfoFromExpressionUtility.GetMethod(() => DomainType.StaticVoidMethod());
var expected = typeof(DomainType).GetMethod("StaticVoidMethod");
Assert.That(member, Is.EqualTo(expected));
}
public void GetConstructor()
{
var member = MemberInfoFromExpressionUtility.GetConstructor(() => new DomainType());
var expected = typeof(DomainType).GetConstructor(Type.EmptyTypes);
Assert.That(member, Is.EqualTo(expected));
}
protected PropertyDefinition GetPropertyDefinition <TSourceObject, TPropertyType> (Expression <Func <TSourceObject, TPropertyType> > expression)
where TSourceObject : DomainObject
{
var propertyInfo = MemberInfoFromExpressionUtility.GetProperty(expression);
var classDefinition = MappingConfiguration.Current.GetTypeDefinition(typeof(TSourceObject));
return(classDefinition.ResolveProperty(PropertyInfoAdapter.Create(propertyInfo)));
}
public void GetMember_Instance_MemberExpression_OverridingProperty()
{
var member = MemberInfoFromExpressionUtility.GetMember((DomainType obj) => obj.OverridingProperty);
var expected = typeof(DomainTypeBase).GetProperty("OverridingProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetMember_Instance_MethodCallExpression()
{
var member = MemberInfoFromExpressionUtility.GetMember((DomainType obj) => obj.InstanceMethod());
var expected = typeof(DomainType).GetMember("InstanceMethod").Single();
Assert.That(member, Is.EqualTo(expected));
}
public void GetProperty_Instance_VirtualBaseProperty()
{
var member = MemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.VirtualBaseProperty);
var expected = typeof(DomainTypeBase).GetProperty("VirtualBaseProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetProperty_FromInterface()
{
var member = MemberInfoFromExpressionUtility.GetProperty((IDomainInterface obj) => obj.InterfaceProperty);
var expected = typeof(IDomainInterface).GetProperty("InterfaceProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetProperty_Static()
{
var member = MemberInfoFromExpressionUtility.GetProperty(() => DomainType.StaticProperty);
var expected = typeof(DomainType).GetProperty("StaticProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetMember_Static_NewExpression()
{
var member = MemberInfoFromExpressionUtility.GetMember(() => new DomainType());
var expected = typeof(DomainType).GetMember(".ctor").Single();
Assert.That(member, Is.EqualTo(expected));
}
public void GetMember_Static_MethodCallExpression()
{
var member = MemberInfoFromExpressionUtility.GetMember(() => DomainType.StaticMethod());
var expected = typeof(DomainType).GetMember("StaticMethod").Single();
Assert.That(member, Is.EqualTo(expected));
}
public void GetGenericMethodDefinition_Instance_OverridingMethod()
{
var member = MemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType obj) => obj.OverridingGenericMethod <SampleType> (null));
var expected = typeof(DomainTypeBase).GetMethod("OverridingGenericMethod");
Assert.That(member, Is.EqualTo(expected));
}
public void GetGenericMethodDefinition_Static()
{
var member = MemberInfoFromExpressionUtility.GetGenericMethodDefinition(() => DomainType.StaticGenericMethod <SampleType> (null));
var expected = typeof(DomainType).GetMethod("StaticGenericMethod");
Assert.That(member, Is.EqualTo(expected));
}
public void GetMethod_Instance_InterfaceMethod()
{
var member = MemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.InterfaceMethod());
var expected = typeof(DomainType).GetMethod("InterfaceMethod");
Assert.That(member, Is.EqualTo(expected));
}
public void GetMethod_Instance_GenericMethod()
{
var member = MemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.InstanceGenericMethod <SampleType> (null));
var expected = typeof(DomainType).GetMethod("InstanceGenericMethod").MakeGenericMethod(typeof(SampleType));
Assert.That(member, Is.EqualTo(expected));
}
public void GetMethod_Instance_Overriding()
{
var member = MemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.OverridingMethod());
var expected = typeof(DomainTypeBase).GetMethod("OverridingMethod");
Assert.That(member, Is.EqualTo(expected));
}
public void AccessorMethod_ReturnsPropertyInfo()
{
var accessorMethod = typeof(DomainType).GetMethod("get_Property", BindingFlags.Instance | BindingFlags.Public);
var propertyInfo = MemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.Property);
var result = accessorMethod.GetRelatedPropertyInfo();
Assert.That(result, Is.EqualTo(propertyInfo));
}
