public void GetOriginalDeclaration_WithPropertyIsOverriddenDeclaration()
{
var propertyInfo = typeof(DerivedClassWithReferenceType <object>).GetProperty("PropertyWithPrivateSetter");
var adapter = PropertyInfoAdapter.Create(propertyInfo);
var result = adapter.GetOriginalDeclaration();
Assert.That(result, Is.Not.Null);
var expectedPropertyInfo = typeof(ClassWithReferenceType <object>).GetProperty("PropertyWithPrivateSetter");
CheckPropertyInfo(expectedPropertyInfo, (PropertyInfoAdapter)result);
}
public void GetAccessors_Setter()
{
var propertyInfo = typeof(ClassWithReferenceType <object>).GetProperty("ImplicitInterfaceWriteOnlyScalar");
var adapter = PropertyInfoAdapter.Create(propertyInfo);
var result = adapter.GetAccessors(false);
Assert.That(result.Length, Is.EqualTo(1));
var expectedMethodInfo = typeof(ClassWithReferenceType <object>).GetMethod("set_ImplicitInterfaceWriteOnlyScalar");
CheckMethodInfo(expectedMethodInfo, (MethodInfoAdapter)result[0]);
}
public void IsVirtualRelationEndPoint_UnidirectionalRelation()
{
var type = typeof(ClassWithRealRelationEndPoints);
var propertyInfo = PropertyInfoAdapter.Create(type.GetProperty("Unidirectional"));
var relationEndPointReflector = new RdbmsRelationEndPointReflector(
ClassDefinitionObjectMother.CreateClassDefinition(classType: type),
propertyInfo,
Configuration.NameResolver,
PropertyMetadataProvider,
DomainModelConstraintProviderStub);
Assert.That(relationEndPointReflector.IsVirtualEndRelationEndpoint(), Is.False);
}
public void GetAccessors_NonPublicSetter_NonPublicFalse()
{
var propertyInfo = typeof(ClassWithReferenceType <object>).GetProperty("PropertyWithPrivateSetter");
var adapter = PropertyInfoAdapter.Create(propertyInfo);
var result = adapter.GetAccessors(false);
Assert.That(result.Length, Is.EqualTo(1));
var expectedMethodInfo = typeof(ClassWithReferenceType <object>).GetMethod("get_PropertyWithPrivateSetter");
CheckMethodInfo(expectedMethodInfo, (MethodInfoAdapter)result[0]);
}
private PropertyReflector CreatePropertyReflector(string property)
{
Type type = typeof(ClosedGenericClassWithRealRelationEndPoints);
var propertyInfo =
PropertyInfoAdapter.Create(type.GetProperty(property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
return(new PropertyReflector(
_classDefinition,
propertyInfo,
Configuration.NameResolver,
PropertyMetadataProvider,
DomainModelConstraintProviderStub));
}
public void IsVirtualEndRelationEndpoint_WithCollectionPropertyAndWithoutAttribute()
{
var type = typeof(ClassWithInvalidUnidirectionalRelation);
var propertyInfo = PropertyInfoAdapter.Create(type.GetProperty("LeftSide"));
var relationEndPointReflector = RelationEndPointReflector.CreateRelationEndPointReflector(
ClassDefinitionObjectMother.CreateClassDefinition(classType: type),
propertyInfo,
Configuration.NameResolver,
PropertyMetadataProvider,
DomainModelConstraintProviderStub);
Assert.That(relationEndPointReflector.IsVirtualEndRelationEndpoint(), Is.False);
}
public void CreateRelationEndPointReflector()
{
var type = typeof(ClassWithVirtualRelationEndPoints);
var propertyInfo = PropertyInfoAdapter.Create(type.GetProperty("NoAttribute"));
Assert.IsInstanceOf(
typeof(RdbmsRelationEndPointReflector),
RelationEndPointReflector.CreateRelationEndPointReflector(
ClassDefinitionObjectMother.CreateClassDefinition(classType: type),
propertyInfo,
Configuration.NameResolver,
PropertyMetadataProvider,
DomainModelConstraintProviderStub));
}
public void CanRead_WithSecurableObject_WithoutSetter_UsesNullMethodInfo_ReturnsResult()
{
var expectedResult = BooleanObjectMother.GetRandomBoolean();
ExpectHasAccessOnObjectSecurityStrategy(expectedResult, GeneralAccessTypes.Read);
var bindableProperty = new StubPropertyBase(
GetPropertyParameters(PropertyInfoAdapter.Create(typeof(ClassWithReferenceType <string>).GetProperty("PropertyWithNoGetter"))));
var actualResult = _strategy.CanRead(_securableObject, bindableProperty);
Assert.That(actualResult, Is.EqualTo(expectedResult));
_objectSecurityStrategyMock.VerifyAllExpectations();
}
private static PropertyInfoAdapter GetMemberAsProperty(SqlEntityExpression originatingEntity, MemberInfo memberInfo)
{
var property = memberInfo as PropertyInfo;
if (property == null)
{
throw new UnmappedItemException(
string.Format(
"Field '{0}.{1}' cannot be used in a query because it is not a mapped member.",
originatingEntity.Type.Name,
memberInfo.Name));
}
return(PropertyInfoAdapter.Create(property));
}
public void GetMetadata_ForMandatory()
{
var propertyInfo = PropertyInfoAdapter.Create(_classType.GetProperty("NotNullable"));
var relationEndPointReflector = CreateRelationEndPointReflector(propertyInfo);
DomainModelConstraintProviderStub.Stub(stub => stub.IsNullable(propertyInfo)).Return(false);
IRelationEndPointDefinition actual = relationEndPointReflector.GetMetadata();
Assert.IsInstanceOf(typeof(VirtualRelationEndPointDefinition), actual);
Assert.That(actual.PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.ReflectionBasedMappingSample.ClassWithVirtualRelationEndPoints.NotNullable"));
Assert.That(actual.IsMandatory, Is.True);
DomainModelConstraintProviderStub.VerifyAllExpectations();
}
public void FindInterfaceDeclarations_ImplicitInterfaceImplementation()
{
var adapter = PropertyInfoAdapter.Create(typeof(ClassWithReferenceType <object>).GetProperty("ImplicitInterfaceScalar"));
var result = adapter.FindInterfaceDeclarations();
var expectedPropertyInfos =
new[]
{
MemberInfoFromExpressionUtility.GetProperty((IInterfaceWithReferenceType <object> obj) => obj.ImplicitInterfaceScalar)
};
CheckUnorderedPropertyInfos(expectedPropertyInfos, result.Cast <PropertyInfoAdapter>());
}
public void Initialize_IndexedProperty()
{
IPropertyInformation propertyInfo =
PropertyInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) }));
new StubPropertyBase(
CreateParameters(
propertyInfo: propertyInfo,
underlyingType: propertyInfo.PropertyType,
concreteType: propertyInfo.PropertyType,
listInfo: null,
isRequired: true,
isReadOnly: true));
}
public void SetUp()
{
_addingComponentPropertyRuleMock = MockRepository.GenerateStrictMock <IAddingComponentPropertyRule>();
_addingComponentPropertyRuleMock.Stub(stub => stub.Property).Return(PropertyInfoAdapter.Create(typeof(Customer).GetProperty("UserName")));
_addingComponentPropertyMetaValidationRuleMock = MockRepository.GenerateStrictMock <IAddingComponentPropertyMetaValidationRule>();
_addingComponentPropertyRuleMock.Stub(stub => stub.Property).Return(PropertyInfoAdapter.Create(typeof(Customer).GetProperty("UserName")));
_addingComponentBuilder = new AddingComponentRuleBuilder <Customer, string> (
_addingComponentPropertyRuleMock,
_addingComponentPropertyMetaValidationRuleMock);
_propertyValidatorStub = MockRepository.GenerateStub <IPropertyValidator>();
}
public void ResolveDefinition_ClassWithSameInterfaceAsMixin_BothStorageClassPersistent()
{
var property = PropertyInfoAdapter.Create(typeof(IInterfaceWithProperty).GetProperty("Property"));
var classDefinition = GetTypeDefinition(typeof(ClassWithSameInterfaceAsMixinWithStorageClassPersistent));
Assert.That(() => ReflectionBasedPropertyResolver.ResolveDefinition(
property, classDefinition, classDefinition.GetPropertyDefinition),
Throws.TypeOf <InvalidOperationException> ().With.Message.EqualTo(
"The property 'Property' is ambiguous, it is implemented by the following types valid in the context of class "
+ "'ClassWithSameInterfaceAsMixinWithStorageClassPersistent': "
+ "'Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.ReflectionBasedPropertyResolver.ClassWithSameInterfaceAsMixinWithStorageClassPersistent', "
+ "'Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.ReflectionBasedPropertyResolver.MixinWithPersistentProperty'."));
}
public void SetUp()
{
_property = PropertyInfoAdapter.Create(typeof(Customer).GetProperty("UserName"));
_userNameExpression = ExpressionHelper.GetTypedMemberExpression <Customer, string> (c => c.UserName);
_lastNameExpression = ExpressionHelper.GetTypedMemberExpression <Customer, string> (c => c.LastName);
_stubPropertyValidator1 = new StubPropertyValidator();
_stubPropertyValidator2 = new NotEmptyValidator(null);
_stubPropertyValidator3 = new NotEqualValidator("gfsf");
_propertyValidatorExtractorMock = MockRepository.GenerateStrictMock <IPropertyValidatorExtractor>();
_addingComponentPropertyRule = AddingComponentPropertyRule.Create(_userNameExpression, typeof(CustomerValidationCollector1));
}
public void SetValue_WithIndexerProperty_WithOneParameter()
{
var scalar = new SimpleReferenceType();
var instanceMock = MockRepository.GenerateMock <IInterfaceWithReferenceType <SimpleReferenceType> >();
instanceMock.Expect(mock => mock[10] = scalar);
instanceMock.Replay();
var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) });
_implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty);
_implicitInterfaceAdapter.SetValue(instanceMock, scalar, new object[] { 10 });
instanceMock.VerifyAllExpectations();
}
public void BidirectionalRelation_PropertyTypeDomainObject()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"DomainObjectPropertyWithBidirectionalAttribute",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass).GetProperty("DomainObjectPropertyWithBidirectionalAttribute")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void PropertyWithNoDBBidirectionalRelationAttribute()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"PropertyWithNoDbBidirectionalRelationAttribute",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(ForeignKeyIsSupportedClass).GetProperty("PropertyWithNoDbBidirectionalRelationAttribute")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void Equals_ChecksPropertyInfo()
{
Assert.That(_mixinIntroducedPropertyInformation.Equals(null), Is.False);
Assert.That(_mixinIntroducedPropertyInformation.Equals("Test"), Is.False);
Assert.That(
_mixinIntroducedPropertyInformation.Equals(
new MixinIntroducedPropertyInformation(
new InterfaceImplementationPropertyInformation(
PropertyInfoAdapter.Create(typeof(string).GetProperty("Length")),
PropertyInfoAdapter.Create(typeof(string).GetProperty("Length"))))),
Is.False);
Assert.That(
_mixinIntroducedPropertyInformation.Equals(new MixinIntroducedPropertyInformation(_interfaceImplementationPropertyInformation)), Is.True);
}
public void SetUp()
{
_property = typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("NotVisibleAttributeScalar");
_adapter = PropertyInfoAdapter.Create(_property);
_explicitInterfaceImplementationProperty = typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty(
"Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.ExplicitInterfaceScalar",
BindingFlags.NonPublic | BindingFlags.Instance);
_explicitInterfaceAdapter = PropertyInfoAdapter.Create(_explicitInterfaceImplementationProperty);
_implicitInterfaceImplementationProperty = typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty(
"ImplicitInterfaceScalar",
BindingFlags.Public | BindingFlags.Instance);
_implicitInterfaceAdapter = PropertyInfoAdapter.Create(_implicitInterfaceImplementationProperty);
}
public void NoCollectionProperty_ContainsForeignKeyIsTrue()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"NoCollectionProperty_ContainsForeignKey",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(ForeignKeyIsSupportedClass).GetProperty("NoCollectionProperty_ContainsForeignKey")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void TryGetPropertyDisplayName()
{
var service = SafeServiceLocator.Current.GetInstance <IMemberInformationGlobalizationService>();
string resourceValue;
Assert.That(
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithProperties).GetProperty("PropertyWithShortIdentifier")),
TypeAdapter.Create(typeof(ClassWithResources)),
out resourceValue),
Is.True);
Assert.That(resourceValue, Is.EqualTo("Short Property ID"));
Assert.That(
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithProperties).GetProperty("PropertyWithLongIdentifier")),
TypeAdapter.Create(typeof(ClassWithResources)),
out resourceValue),
Is.True);
Assert.That(resourceValue, Is.EqualTo("Long Property ID"));
Assert.That(
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithProperties).GetProperty("PropertyWithoutResources")),
TypeAdapter.Create(typeof(ClassWithResources)),
out resourceValue),
Is.False);
Assert.That(resourceValue, Is.Null);
Assert.That(
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithProperties).GetProperty("PropertyWithLongIdentifier")),
TypeAdapter.Create(typeof(ClassWithoutMultiLingualResourcesAttributes)),
out resourceValue),
Is.False);
Assert.That(resourceValue, Is.Null);
Assert.That(
() => service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithProperties).GetProperty("PropertyWithLongIdentifier")),
TypeAdapter.Create(typeof(ClassWithMissingResources)),
out resourceValue),
Throws.TypeOf <MissingManifestResourceException>()
.With.Message.EqualTo(
"Could not find any resources appropriate for the neutral culture. "
+ "Make sure 'MissingResources.resources' was correctly embedded into assembly 'Remotion.Globalization.UnitTests' at compile time."));
}
public void TryGetPropertyDisplayName_WithMultiLingualNameAttributeAppliedToOverride_ThrowsInvalidOperationException()
{
var service = SafeServiceLocator.Current.GetInstance <IMemberInformationGlobalizationService>();
string resourceValue;
Assert.That(
() =>
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(
typeof(DerivedClassWithMultiLingualNameAttribute)
.GetProperty("PropertyWithMultiLingualNameAttributeOnOverride")),
TypeAdapter.Create(typeof(ClassWithoutMultiLingualResourcesAttributes)),
out resourceValue),
Throws.InvalidOperationException);
}
public void EqualsTest()
{
Assert.That(_interfaceImplementationPropertyInformation.Equals(null), Is.False);
Assert.That(_interfaceImplementationPropertyInformation.Equals("Test"), Is.False);
Assert.That(
_interfaceImplementationPropertyInformation.Equals(
new InterfaceImplementationPropertyInformation(
PropertyInfoAdapter.Create(typeof(string).GetProperty("Length")),
PropertyInfoAdapter.Create(typeof(string).GetProperty("Length")))),
Is.False);
Assert.That(
_interfaceImplementationPropertyInformation.Equals(
new InterfaceImplementationPropertyInformation(_implementationPropertyInformationStub, _declarationPropertyInformationStub)),
Is.True);
}
public void TryGetPropertyDisplayName()
{
var service = SafeServiceLocator.Current.GetInstance <IMemberInformationGlobalizationService>();
using (new CultureScope("it", "de-AT"))
{
string resourceValue;
Assert.That(
service.TryGetPropertyDisplayName(
PropertyInfoAdapter.Create(typeof(ClassWithMultiLingualNameAttribute).GetProperty("PropertyWithMultiLingualNameAttribute")),
TypeAdapter.Create(typeof(ClassWithResources)),
out resourceValue),
Is.True);
Assert.That(resourceValue, Is.EqualTo("Resource-based Property ID"));
}
}
public void SetValue_WithIndexerProperty_WithThreeParameters()
{
SimpleReferenceType scalar = new SimpleReferenceType();
IInterfaceWithReferenceType <SimpleReferenceType> instanceMock = MockRepository.GenerateMock <IInterfaceWithReferenceType <SimpleReferenceType> >();
instanceMock.Expect(mock => mock[10, new DateTime(2000, 1, 1), "foo"] = scalar);
instanceMock.Replay();
var interfaceDeclarationProperty = typeof(IInterfaceWithReferenceType <SimpleReferenceType>)
.GetProperty("Item", new[] { typeof(int), typeof(DateTime), typeof(string) });
_implicitInterfaceAdapter = PropertyInfoAdapter.Create(interfaceDeclarationProperty);
_implicitInterfaceAdapter.SetValue(instanceMock, scalar, new object[] { 10, new DateTime(2000, 1, 1), "foo" });
instanceMock.VerifyAllExpectations();
}
public void FindInterfaceDeclarations_ExplicitInterfaceImplementation_ReadOnlyProperty()
{
var adapter = PropertyInfoAdapter.Create(typeof(ClassWithReferenceType <object>).GetProperty(
"Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.ExplicitInterfaceReadOnlyScalar",
BindingFlags.Instance | BindingFlags.NonPublic));
var result = adapter.FindInterfaceDeclarations();
var expectedPropertyInfos =
new[]
{
MemberInfoFromExpressionUtility.GetProperty((IInterfaceWithReferenceType <object> obj) => obj.ExplicitInterfaceReadOnlyScalar)
};
CheckUnorderedPropertyInfos(expectedPropertyInfos, result.Cast <PropertyInfoAdapter> ());
}
public void FindInterfaceDeclarations_MultipleDeclarations()
{
var propertyInfo = MemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.PropertyDeclaredByMultipleInterfaces);
var adapter = PropertyInfoAdapter.Create(propertyInfo);
var result = adapter.FindInterfaceDeclarations();
var expectedPropertyInfos =
new[]
{
MemberInfoFromExpressionUtility.GetProperty((IInterface1 obj) => obj.PropertyDeclaredByMultipleInterfaces),
MemberInfoFromExpressionUtility.GetProperty((IInterface2 obj) => obj.PropertyDeclaredByMultipleInterfaces)
};
CheckUnorderedPropertyInfos(expectedPropertyInfos, result.Cast <PropertyInfoAdapter>());
}
public void ResolveDefinition_ExplicitMixinProperty_FromInterfaceProperty()
{
var property = PropertyInfoAdapter.Create(typeof(IInterfaceWithProperty).GetProperty("Property"));
var classDefinition = GetTypeDefinition(typeof(ClassWithMixinWithPersistentPropertyExplicitImplementation));
var result = ReflectionBasedPropertyResolver.ResolveDefinition(property, classDefinition, classDefinition.GetPropertyDefinition);
var implementationPropertyName = property.DeclaringType.FullName + "." + property.Name;
var expected = GetPropertyDefinition(
typeof(ClassWithMixinWithPersistentPropertyExplicitImplementation),
typeof(MixinWithPersistentPropertyExplicitImplementation),
implementationPropertyName);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.SameAs(expected));
}
public void GetAccessors_NonPublicSetter_NonPublicTrue()
{
var propertyInfo = typeof(ClassWithReferenceType <object>).GetProperty("PropertyWithPrivateSetter");
var adapter = PropertyInfoAdapter.Create(propertyInfo);
var result = adapter.GetAccessors(true);
Assert.That(result.Length, Is.EqualTo(2));
var expectedMethodInfo0 = typeof(ClassWithReferenceType <object>).GetMethod("get_PropertyWithPrivateSetter");
var expectedMethodInfo1 = typeof(ClassWithReferenceType <object>).GetMethod(
"set_PropertyWithPrivateSetter", BindingFlags.Instance | BindingFlags.NonPublic);
CheckMethodInfo(expectedMethodInfo0, (MethodInfoAdapter)result[0]);
CheckMethodInfo(expectedMethodInfo1, (MethodInfoAdapter)result[1]);
}
