public void SetCustomAttribute()
{
var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null));
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((AbcAttribute obj) => obj.StringProperty);
var field = NormalizingMemberInfoFromExpressionUtility.GetField((AbcAttribute obj) => obj.IntField);
var wasCalled = false;
Action <CustomAttributeBuilder> setCustomAttributeMethod = customAttributeBuilder =>
{
wasCalled = true;
Assert.That(customAttributeBuilder, Is.Not.Null);
CheckCustomAttributeBuilder(
customAttributeBuilder,
attributeCtor,
new object[] { typeof(int) },
new[] { property },
new object[] { "def" },
new[] { field },
new object[] { 8 });
};
var adapterBasePartialMock = MockRepository.GeneratePartialMock <BuilderAdapterBase> (setCustomAttributeMethod);
var declaration = new CustomAttributeDeclaration(
attributeCtor, new object[] { typeof(int) }, new NamedArgumentDeclaration(property, "def"), new NamedArgumentDeclaration(field, 8));
adapterBasePartialMock.SetCustomAttribute(declaration);
Assert.That(wasCalled, Is.True);
}
public void OverrideExisting_AddCustomAttribute()
{
var type = AssembleType <DomainType> (
proxyType =>
{
var existingProperty = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.ExistingProperty);
var getMethod = proxyType.GetOrAddOverride(existingProperty.GetGetMethod());
var setMethod = proxyType.GetOrAddOverride(existingProperty.GetSetMethod());
var property = proxyType.AddProperty(existingProperty.Name, PropertyAttributes.None, getMethod, setMethod);
var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(""));
var customAttributes = new CustomAttributeDeclaration(attributeCtor, new object[] { "derived" });
property.AddCustomAttribute(customAttributes);
});
var newProperty = type.GetProperty("ExistingProperty");
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.ExistingProperty, Is.Null);
Assert.That(newProperty.GetValue(instance, null), Is.Null);
newProperty.SetValue(instance, "Test", null);
Assert.That(instance.ExistingProperty, Is.EqualTo("Test"));
Assert.That(newProperty.GetValue(instance, null), Is.EqualTo("Test"));
var attributeArgs = Attribute.GetCustomAttributes(newProperty, inherit: true).Cast <AbcAttribute>().Select(a => a.Arg);
Assert.That(attributeArgs, Is.EquivalentTo(new[] { "base", "derived" }));
}
public void CreateSequenceQuery_EntityQuery_WithFetchRequestWithSortExpressionBasedOnMixinProperty()
{
var fakeSqlQuery = CreateSqlQueryGeneratorResult(selectedEntityType: typeof(RelationTargetForPersistentMixin));
var targetTypeQueryModel = QueryModelObjectMother.Create(Expression.Constant(null, typeof(RelationTargetForPersistentMixin)));
_sqlQueryGeneratorMock.Stub(stub => stub.CreateSqlQuery(targetTypeQueryModel)).Return(fakeSqlQuery);
var fetchQueryModelBuilder = CreateFetchManyQueryModelBuilder((RelationTargetForPersistentMixin o) => o.RelationProperty4, targetTypeQueryModel);
var fakeFetchSqlQueryResult = CreateSqlQueryGeneratorResult("FETCH");
_sqlQueryGeneratorMock
.Expect(mock => mock.CreateSqlQuery(Arg <QueryModel> .Is.Anything))
.Return(fakeFetchSqlQueryResult)
.WhenCalled(mi =>
{
var actualQueryModel = (QueryModel)mi.Arguments[0];
var fetchQueryModel = fetchQueryModelBuilder.GetOrCreateFetchQueryModel();
Assert.That(actualQueryModel.MainFromClause.FromExpression, Is.TypeOf <SubQueryExpression> ());
CheckActualFetchQueryModel(((SubQueryExpression)actualQueryModel.MainFromClause.FromExpression).QueryModel, fetchQueryModel);
Assert.That(actualQueryModel.BodyClauses, Has.Some.TypeOf <OrderByClause> ());
var orderByClause = (OrderByClause)actualQueryModel.BodyClauses.Single();
var endPointDefinition = ((VirtualRelationEndPointDefinition)GetEndPointDefinition(typeof(RelationTargetForPersistentMixin), "RelationProperty4"));
Assert.That(endPointDefinition.SortExpressionText,
Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.MixedDomains.TestDomain.MixinAddingPersistentProperties.PersistentProperty ASC"));
var sortedByMember = NormalizingMemberInfoFromExpressionUtility.GetProperty((IMixinAddingPersistentProperties o) => o.PersistentProperty);
Assert.That(((MemberExpression)orderByClause.Orderings[0].Expression).Member, Is.SameAs(sortedByMember));
Assert.That(orderByClause.Orderings[0].OrderingDirection, Is.EqualTo(OrderingDirection.Asc));
});
_generator.CreateSequenceQuery <int> ("id", TestDomainStorageProviderDefinition, targetTypeQueryModel, new[] { fetchQueryModelBuilder });
_sqlQueryGeneratorMock.VerifyAllExpectations();
}
protected RelationEndPointDefinition GetRelationEndPointDefinition <TSource, TRelated> (Expression <Func <TSource, TRelated> > propertyAccessExpression)
{
var typeDefinition = MappingConfiguration.GetTypeDefinition(typeof(TSource));
var propertyInfoAdapter = PropertyInfoAdapter.Create(NormalizingMemberInfoFromExpressionUtility.GetProperty(propertyAccessExpression));
return((RelationEndPointDefinition)typeDefinition.ResolveRelationEndPoint(propertyInfoAdapter));
}
public void Initialization_InvalidMemberDeclaringType()
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute());
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DerivedAttribute attr) => attr.PropertyInDerivedType);
new CustomAttributeDeclaration(constructor, new object[0], new NamedArgumentDeclaration(property, 7));
}
public void CreateSequenceQuery_EntityQuery_WithFetchRequestWithSortExpression()
{
var fakeSqlQuery = CreateSqlQueryGeneratorResult(selectedEntityType: typeof(Customer));
_sqlQueryGeneratorMock.Stub(stub => stub.CreateSqlQuery(_customerQueryModel)).Return(fakeSqlQuery);
var fetchQueryModelBuilder = CreateFetchManyQueryModelBuilder((Customer o) => o.Orders);
var fakeFetchSqlQueryResult = CreateSqlQueryGeneratorResult("FETCH");
_sqlQueryGeneratorMock
.Expect(mock => mock.CreateSqlQuery(Arg <QueryModel> .Is.Anything))
.Return(fakeFetchSqlQueryResult)
.WhenCalled(mi =>
{
var actualQueryModel = (QueryModel)mi.Arguments[0];
var fetchQueryModel = fetchQueryModelBuilder.GetOrCreateFetchQueryModel();
Assert.That(actualQueryModel.MainFromClause.FromExpression, Is.TypeOf <SubQueryExpression> ());
CheckActualFetchQueryModel(((SubQueryExpression)actualQueryModel.MainFromClause.FromExpression).QueryModel, fetchQueryModel);
Assert.That(actualQueryModel.BodyClauses, Has.Some.TypeOf <OrderByClause> ());
var orderByClause = (OrderByClause)actualQueryModel.BodyClauses.Single();
var endPointDefinition = ((VirtualRelationEndPointDefinition)GetEndPointDefinition(typeof(Customer), "Orders"));
Assert.That(endPointDefinition.SortExpressionText, Is.EqualTo("OrderNumber asc"));
var orderNumberMember = NormalizingMemberInfoFromExpressionUtility.GetProperty((Order o) => o.OrderNumber);
Assert.That(((MemberExpression)orderByClause.Orderings[0].Expression).Member, Is.SameAs(orderNumberMember));
Assert.That(orderByClause.Orderings[0].OrderingDirection, Is.EqualTo(OrderingDirection.Asc));
});
_generator.CreateSequenceQuery <int> ("id", TestDomainStorageProviderDefinition, _customerQueryModel, new[] { fetchQueryModelBuilder });
_sqlQueryGeneratorMock.VerifyAllExpectations();
}
public void CreateAspectInitExpression_NamedElementArgument()
{
var namedFieldArgumentMock = MockRepository.GenerateStrictMock <ICustomAttributeNamedArgument> ();
var namedPropertyArgumentMock = MockRepository.GenerateStrictMock <ICustomAttributeNamedArgument> ();
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAspect obj) => obj.FieldElementArg);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAspect obj) => obj.PropertyElementArg);
namedFieldArgumentMock.Expect(x => x.MemberInfo).Return(field);
namedFieldArgumentMock.Expect(x => x.MemberType).Return(field.FieldType);
namedFieldArgumentMock.Expect(x => x.Value).Return("field");
namedPropertyArgumentMock.Expect(x => x.MemberInfo).Return(property);
namedPropertyArgumentMock.Expect(x => x.MemberType).Return(property.PropertyType);
namedPropertyArgumentMock.Expect(x => x.Value).Return("prop");
SetupConstructionMock(namedArguments: new[] { namedFieldArgumentMock, namedPropertyArgumentMock });
var result = _initializationExpressionHelper.CreateAspectInitExpression(_constructionMock);
Assert.That(result.Bindings, Has.Count.EqualTo(2));
var assignment1 = (MemberAssignment)result.Bindings[0];
Assert.That(assignment1.Member, Is.EqualTo(field));
Assert.That(assignment1.Expression, Is.TypeOf <ConstantExpression> ().With.Property("Value").EqualTo("field"));
var assignment2 = (MemberAssignment)result.Bindings[1];
Assert.That(assignment2.Member, Is.EqualTo(property));
Assert.That(assignment2.Expression, Is.TypeOf <ConstantExpression> ().With.Property("Value").EqualTo("prop"));
}
public void Initialization()
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((ValueType)null));
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property);
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field);
var declaration = new CustomAttributeDeclaration(
constructor,
new object[] { 7 },
new NamedArgumentDeclaration(property, 7),
new NamedArgumentDeclaration(field, "value"));
Assert.That(declaration.Type, Is.SameAs(typeof(DomainAttribute)));
Assert.That(declaration.Constructor, Is.SameAs(constructor));
Assert.That(declaration.ConstructorArguments, Is.EqualTo(new[] { 7 }));
var actualNamedArguments = declaration.NamedArguments.Select(na => new { na.MemberInfo, na.Value });
var expectedNamedArguments =
new[]
{
new { MemberInfo = (MemberInfo)property, Value = (object)7 },
new { MemberInfo = (MemberInfo)field, Value = (object)"value" }
};
Assert.That(actualNamedArguments, Is.EqualTo(expectedNamedArguments));
}
public void GetCustomAttributes_Inheritance_BehavesLikeReflection()
{
var type = typeof(DomainType);
var mutableType = MutableTypeObjectMother.Create(type);
CheckAttributeInheritance(mutableType, type);
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
var mutableMethod = mutableType.GetOrAddOverride(method);
CheckAttributeInheritance(mutableMethod, method);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.Property);
var mutableGetMethod = mutableType.GetOrAddOverride(property.GetGetMethod());
var mutableSetMethod = mutableType.GetOrAddOverride(property.GetSetMethod());
var mutableProperty = mutableType.AddProperty(property.Name, property.Attributes, mutableGetMethod, mutableSetMethod);
CheckAttributeInheritance(mutableProperty, property);
var event_ = typeof(DomainType).GetEvent("Event");
var mutableAddMethod = mutableType.GetOrAddOverride(event_.GetAddMethod());
var mutableRemoveMethod = mutableType.GetOrAddOverride(event_.GetRemoveMethod());
var mutableEvent = mutableType.AddEvent(event_.Name, event_.Attributes, mutableAddMethod, mutableRemoveMethod);
CheckAttributeInheritance(mutableEvent, event_);
}
public void AccessMembers()
{
var overriddenMethod =
NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.GenericMethod <Constraint> (null, ""));
var field = NormalizingMemberInfoFromExpressionUtility.GetField((Constraint o) => o.Field);
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((Constraint o) => o.Method(""));
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((Constraint o) => o.Property);
var type = AssembleType <DomainType> (p => p.GetOrAddOverride(overriddenMethod).SetBody(ctx =>
{
var parameter = ctx.Parameters[0];
var variable = Expression.Variable(typeof(string));
// TODO 5480: Remove conversion and inline.
var castedParameter = Expression.Convert(parameter, typeof(Constraint));
return(Expression.Block(
new[] { variable },
Expression.Assign(variable, Expression.Call(castedParameter, method, ctx.Parameters[1])),
Expression.Assign(Expression.Field(castedParameter, field), variable),
Expression.Assign(Expression.Property(castedParameter, property), Expression.Field(castedParameter, field)),
Expression.Property(castedParameter, property)));
}));
var instance = (DomainType)Activator.CreateInstance(type);
var arg = new Constraint();
var result = instance.GenericMethod(arg, "abc");
Assert.That(arg.Field, Is.EqualTo("method: abc"));
Assert.That(arg.Property, Is.EqualTo("method: abc"));
Assert.That(result, Is.EqualTo("method: abc"));
}
public void GetBaseProperty_Shadowed()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.ShadowingProperty);
var result = _finder.GetBaseProperty(property);
Assert.That(result, Is.Null);
}
public void GetBaseProperty_NoBaseMethod()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((BaseBaseType obj) => obj.OverridingProperty);
var result = _finder.GetBaseProperty(property);
Assert.That(result, Is.Null);
}
public void GetAllProperties()
{
var result = _constrainedParameter.GetAllProperties();
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.Property);
Assert.That(result, Is.EqualTo(new[] { property }));
}
private FetchRequestBase AddFetchRequest(QueryModel queryModel)
{
var relationMember = NormalizingMemberInfoFromExpressionUtility.GetProperty((Order o) => o.OrderTicket);
var fetchRequest = new FetchOneRequest(relationMember);
queryModel.ResultOperators.Add(fetchRequest);
return(fetchRequest);
}
public void GetPropertySignature()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.Property);
var result = SignatureDebugStringGenerator.GetPropertySignature(property);
Assert.That(result, Is.EqualTo("String Property"));
}
public void GetProperty_FromCastedInstance()
{
var member = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => ((IDomainInterface)obj).InterfaceProperty);
var expected = typeof(DomainType).GetProperty("InterfaceProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetProperty_Instance_OverridingProperty()
{
var member = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.OverridingProperty);
var expected = typeof(DomainType).GetProperty("OverridingProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetProperty_Instance_SpecialOverridingProperty()
{
var member = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.SpecialOverridingProperty);
var expected = typeof(DomainType).GetProperty("SpecialOverridingProperty", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.That(member, Is.EqualTo(expected));
}
public void GetPropertyInterceptors_UsesMostDerivedOverride()
{
var result = _adapter.GetPropertyInterceptors(_classDefinition, _concreteBaseType);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((MyConcreteBaseType o) => o.OverriddenProperty);
CheckContains(result, property.GetGetMethod(), property.GetSetMethod());
}
public void GetProperty_Static()
{
var member = NormalizingMemberInfoFromExpressionUtility.GetProperty(() => DomainType.StaticProperty);
var expected = typeof(DomainType).GetProperty("StaticProperty");
Assert.That(member, Is.EqualTo(expected));
}
public void GetPropertyInterceptors_SupportsReadOnlyProperties()
{
var result = _adapter.GetPropertyInterceptors(_classDefinition, _concreteBaseType);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((MyDomainObject o) => o.ReadOnlyProperty);
CheckContains(result, property.GetGetMethod());
}
public void GetPropertyInterceptors_FiltersNonOverridableProperty()
{
var result = _adapter.GetPropertyInterceptors(_classDefinition, _concreteBaseType);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((MyDomainObject o) => o.NonOverridableProperty);
CheckAbsence(result, property.GetGetMethod(), property.GetSetMethod());
}
public void GetPropertyInterceptors_ConsideresNonPublicProperty()
{
var result = _adapter.GetPropertyInterceptors(_classDefinition, _concreteBaseType);
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((MyDomainObject o) => o.NonPublicProperty);
CheckContains(result, property.GetGetMethod(true), property.GetSetMethod(true));
}
public void Initialization_Property_MustBePublic()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty(() => PrivateProperty);
Assert.That(
() => new NamedArgumentDeclaration(property, ""),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo("Property 'PrivateProperty' has no public setter.", "propertyInfo"));
}
public void Initialization_Property_MustNotBeStatic()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty(() => StaticProperty);
Assert.That(
() => new NamedArgumentDeclaration(property, ""),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo("Property 'StaticProperty' is not an instance property.", "propertyInfo"));
}
public void GetMemberSignature_Property()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.Property);
var result = MemberSignatureProvider.GetMemberSignature(property);
Assert.That(result, Is.TypeOf <PropertySignature> ());
Assert.That(result.ToString(), Is.EqualTo("System.String()"));
}
public void GetBaseProperty_NonPublic()
{
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.NonPublicOverridingProperty);
var result = _finder.GetBaseProperty(property);
var expected = NormalizingMemberInfoFromExpressionUtility.GetProperty((BaseType obj) => obj.NonPublicOverridingProperty);
Assert.That(result, Is.EqualTo(expected));
}
public void SetUp()
{
_mutableType = MutableTypeObjectMother.Create(typeof(DomainType));
_publicField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.PublicField);
_publicMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethod(0));
_publicMethodWithOverloadEmpty = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethodWithOverload());
_publicMethodWithOverloadInt = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethodWithOverload(1));
_publicProperty = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.PublicProperty);
_publicPropertyWithIndexParameter = typeof(DomainType).GetProperty("Item");
}
protected PropertyInfoAdapter GetPropertyInformation <T, TR> (Expression <Func <T, TR> > propertyAccessExpression)
{
var memberInfo = NormalizingMemberInfoFromExpressionUtility.GetProperty(propertyAccessExpression);
if (memberInfo.DeclaringType != typeof(T))
{
var message = string.Format("Property must be declared on type '{0}', but it is declared on '{1}'.", typeof(T), memberInfo.DeclaringType);
throw new InvalidOperationException(message);
}
return(PropertyInfoAdapter.Create(memberInfo));
}
public void Initialization_Simple()
{
var namedArgument = CustomAttributeNamedArgument(MethodBase.GetCurrentMethod());
var result = new CustomAttributeNamedArgumentAdapter(namedArgument);
var member = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property);
Assert.That(result.MemberInfo, Is.EqualTo(member));
Assert.That(result.MemberType, Is.EqualTo(typeof(string)));
Assert.That(result.Value, Is.EqualTo("named arg"));
}
