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")); }