public void GetProviderForBindableObjectType() { BindableObjectProvider provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(SimpleBusinessObjectClass)); Assert.That(provider, Is.Not.Null); Assert.That(provider, Is.SameAs(BusinessObjectProvider.GetProvider(typeof(BindableObjectProviderAttribute)))); }
public void NullabilityResolvedFromAboveInheritanceRoot() { var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(BindableDomainObjectAboveInheritanceRoot)); var businessObjectClass = provider.GetBindableObjectClass(typeof(BindableDomainObjectAboveInheritanceRoot)); var notNullableBooleanProperty = businessObjectClass.GetPropertyDefinition("NotNullableBooleanProperty"); Assert.That(notNullableBooleanProperty.IsRequired, Is.True); var notNullableStringProperty = businessObjectClass.GetPropertyDefinition("NotNullableStringPropertyWithLengthConstraint"); Assert.That(notNullableStringProperty.IsRequired, Is.True); var notNullableRelationProperty = businessObjectClass.GetPropertyDefinition("MandatoryUnidirectionalRelation"); Assert.That(notNullableRelationProperty.IsRequired, Is.True); var nullableBooleanProperty = businessObjectClass.GetPropertyDefinition("NullableBooleanProperty"); Assert.That(nullableBooleanProperty.IsRequired, Is.False); var nullableStringProperty = businessObjectClass.GetPropertyDefinition("NullableStringPropertyWithoutLengthConstraint"); Assert.That(nullableStringProperty.IsRequired, Is.False); var nullableRelationProperty = businessObjectClass.GetPropertyDefinition("NotMandatoryUnidirectionalRelation"); Assert.That(nullableRelationProperty.IsRequired, Is.False); }
public IconProxy GetIcon(string businessObjectClass, string businessObject, string arguments) { if (businessObjectClass == null) { return(null); } Type type = TypeUtility.GetType(businessObjectClass, true); var businessObjectProvider = BindableObjectProvider.GetProviderForBindableObjectType(type); var bindableObjectClass = businessObjectProvider.GetBindableObjectClass(type); IBusinessObjectWithIdentity businessObjectWithIdentity = null; if (!string.IsNullOrEmpty(businessObject)) { var businessObjectClassWithIdentity = (IBusinessObjectClassWithIdentity)bindableObjectClass; businessObjectWithIdentity = businessObjectClassWithIdentity.GetObject(businessObject); } var iconInfo = BusinessObjectBoundWebControl.GetIcon(businessObjectWithIdentity, bindableObjectClass.BusinessObjectProvider); if (iconInfo != null) { return(IconProxy.Create(new HttpContextWrapper(Context), iconInfo)); } return(null); }
protected PropertyBase.Parameters CreateParameters( BindableObjectProvider businessObjectProvider, IPropertyInformation propertyInfo, Type underlyingType, Type concreteType, IListInfo listInfo, bool isRequired, bool isReadOnly, IBindablePropertyReadAccessStrategy bindablePropertyReadAccessStrategy = null, IBindablePropertyWriteAccessStrategy bindablePropertyWriteAccessStrategy = null, BindableObjectGlobalizationService bindableObjectGlobalizationService = null) { return(new PropertyBase.Parameters( businessObjectProvider, propertyInfo, underlyingType, new Lazy <Type> (() => concreteType), listInfo, isRequired, isReadOnly, new BindableObjectDefaultValueStrategy(), bindablePropertyReadAccessStrategy ?? SafeServiceLocator.Current.GetInstance <IBindablePropertyReadAccessStrategy>(), bindablePropertyWriteAccessStrategy ?? SafeServiceLocator.Current.GetInstance <IBindablePropertyWriteAccessStrategy>(), bindableObjectGlobalizationService ?? SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>())); }
public void GetBindableObjectClass() { var mockRepository = new MockRepository(); var metadataFactoryMock = mockRepository.StrictMock <IMetadataFactory>(); var classReflectorMock = mockRepository.StrictMock <IClassReflector>(); var provider = new BindableObjectProvider(metadataFactoryMock, _serviceFactoryStub); BindableObjectProvider.SetProvider(typeof(BindableObjectProviderAttribute), provider); Type targetType = typeof(SimpleBusinessObjectClass); Type concreteType = MixinTypeUtility.GetConcreteMixedType(targetType); var expectedBindableObjectClass = new BindableObjectClass( concreteType, provider, SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>(), new PropertyBase[0]); Expect.Call(metadataFactoryMock.CreateClassReflector(targetType, provider)).Return(classReflectorMock); Expect.Call(classReflectorMock.GetMetadata()).Return(expectedBindableObjectClass); mockRepository.ReplayAll(); BindableObjectClass actual = provider.GetBindableObjectClass(targetType); mockRepository.VerifyAll(); Assert.That(actual, Is.SameAs(expectedBindableObjectClass)); }
public void UseBindableObjectProvider_WithBaseClass() { IBusinessObjectReferenceProperty property = new ReferenceProperty( new PropertyBase.Parameters( _bindableObjectProvider, GetPropertyInfo(typeof(ClassWithReferenceToClassDerivedFromBindableObjectBase), "ScalarReference"), typeof(ClassDerivedFromBindableObjectBase), new Lazy <Type> (() => typeof(ClassDerivedFromBindableObjectBase)), null, false, false, new BindableObjectDefaultValueStrategy(), MockRepository.GenerateStub <IBindablePropertyReadAccessStrategy>(), MockRepository.GenerateStub <IBindablePropertyWriteAccessStrategy>(), SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>())); Assert.That(property.ReferenceClass, Is.SameAs(BindableObjectProviderTestHelper.GetBindableObjectClass(typeof(ClassDerivedFromBindableObjectBase)))); Assert.That( property.BusinessObjectProvider, Is.SameAs(BindableObjectProvider.GetProviderForBindableObjectType(typeof(ClassWithReferenceToClassDerivedFromBindableObjectBase)))); Assert.That( property.ReferenceClass.BusinessObjectProvider, Is.SameAs(BindableObjectProvider.GetProviderForBindableObjectType(typeof(ClassDerivedFromBindableObjectBase)))); Assert.That(property.ReferenceClass.BusinessObjectProvider, Is.SameAs(property.BusinessObjectProvider)); }
private IBusinessObjectReferenceProperty GetBusinessObjectProperty(Type bindableObjectType, string propertyName) { var provider = BindableObjectProvider.GetProviderForBindableObjectType(bindableObjectType); var bindableObjectClass = provider.GetBindableObjectClass(bindableObjectType); return((IBusinessObjectReferenceProperty)bindableObjectClass.GetPropertyDefinition(propertyName)); }
public virtual IClassReflector CreateClassReflector(Type targetType, BindableObjectProvider businessObjectProvider) { ArgumentUtility.CheckNotNull("targetType", targetType); ArgumentUtility.CheckNotNull("businessObjectProvider", businessObjectProvider); return(new ClassReflector(targetType, businessObjectProvider, this, _bindableObjectGlobalizationService)); }
public void GetProviderForBindableObjectType_WithIdentityType() { BindableObjectProvider provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(ClassWithIdentity)); Assert.That(provider, Is.Not.Null); Assert.That(provider, Is.SameAs(BusinessObjectProvider.GetProvider(typeof(BindableObjectWithIdentityProviderAttribute)))); Assert.That(provider, Is.Not.SameAs(BusinessObjectProvider.GetProvider(typeof(BindableObjectProviderAttribute)))); }
public override void SetUp() { base.SetUp(); _bindableObjectProvider = new BindableObjectProvider(); _mockRepository = new MockRepository(); _bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>(); }
public void GetIdentifier_ReturnsIdentifier() { var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(TypeOne)); var typeOneClass = provider.GetBindableObjectClass(typeof(TypeOne)); IBusinessObjectPropertyPath path = StaticBusinessObjectPropertyPath.Parse("TypeTwoValue.TypeThreeValue.TypeFourValue.IntValue", typeOneClass); Assert.That(path.Identifier, Is.EqualTo("TypeTwoValue.TypeThreeValue.TypeFourValue.IntValue")); }
public void GetIsDynamic_ReturnsFalse() { var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(TypeOne)); var typeOneClass = provider.GetBindableObjectClass(typeof(TypeOne)); IBusinessObjectPropertyPath path = StaticBusinessObjectPropertyPath.Parse("TypeTwoValue", typeOneClass); Assert.That(path.IsDynamic, Is.False); }
public void CreateClassReflector() { BindableObjectProvider provider = new BindableObjectProvider(); IClassReflector classReflector = BindableObjectMetadataFactory.Create().CreateClassReflector(typeof(TestClass), provider); Assert.That(classReflector.TargetType, Is.SameAs(typeof(TestClass))); Assert.That(classReflector.BusinessObjectProvider, Is.SameAs(provider)); }
public override void SetUp() { base.SetUp(); _type = typeof(DerivedBusinessObjectClass); _businessObjectProvider = new BindableObjectProvider(); _metadataFactory = BindableObjectMetadataFactory.Create(); _bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>(); }
public override void SetUp() { base.SetUp(); _businessObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory(); _mockRepository = new MockRepository(); _mockBusinessObject = _mockRepository.StrictMock <IBusinessObject>(); }
public void GetServiceFactory_WithMixin() { using (MixinConfiguration.BuildNew().ForClass(typeof(BindableObjectServiceFactory)).AddMixin <MixinStub>().EnterScope()) { var provider = new BindableObjectProvider(); Assert.That(provider.ServiceFactory, Is.InstanceOf(typeof(BindableObjectServiceFactory))); Assert.That(provider.ServiceFactory, Is.InstanceOf(typeof(IMixinTarget))); } }
public void GetProvider() { Assert.That( BindableObjectProvider.GetProviderForBindableObjectType(typeof(ClassDerivedFromBindableObjectBase)), Is.SameAs(BusinessObjectProvider.GetProvider <BindableObjectProviderAttribute>())); Assert.That( BindableObjectProvider.GetProviderForBindableObjectType(typeof(ClassDerivedFromBindableObjectBase)), Is.Not.SameAs(BusinessObjectProvider.GetProvider <BindableObjectWithIdentityProviderAttribute>())); }
public override void SetUp() { base.SetUp(); var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(BindableDomainObjectWithProperties)); _businessObjectClassWithProperties = provider.GetBindableObjectClass(typeof(BindableDomainObjectWithProperties)); _businessObjectSampleClass = provider.GetBindableObjectClass(typeof(SampleBindableMixinDomainObject)); }
public void IsBindableObjectImplementation_TrueWithClosedGenericType() { var mixinTargetType = typeof(ManualBusinessObject); var businessObjectType = typeof(GenericBindableObject <string>); Assertion.IsTrue(mixinTargetType.IsAssignableFrom(businessObjectType)); Assert.That(BindableObjectProvider.IsBindableObjectImplementation(businessObjectType), Is.True); }
public override void SetUp() { base.SetUp(); _provider = new BindableObjectProvider(); BindableObjectProvider.SetProvider(typeof(BindableObjectProviderAttribute), _provider); _metadataFactoryStub = MockRepository.GenerateStub <IMetadataFactory>(); _serviceFactoryStub = MockRepository.GenerateStub <IBusinessObjectServiceFactory>(); }
public void GetProviderForBindableObjectType_WithAttributeFromTypeOverridingAttributeFromMixin() { BindableObjectProvider provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(DerivedBusinessObjectClassWithSpecificBusinessObjectProviderAttribute)); Assert.That(provider, Is.Not.Null); Assert.That(provider, Is.SameAs(BusinessObjectProvider.GetProvider(typeof(BindableObjectWithIdentityProviderAttribute)))); Assert.That(provider, Is.Not.SameAs(BusinessObjectProvider.GetProvider(typeof(BindableObjectProviderAttribute)))); }
public static BindableDomainObjectPropertyReflector Create( IPropertyInformation propertyInfo, BindableObjectProvider businessObjectProvider, IDomainModelConstraintProvider domainModelConstraintProvider, IDefaultValueStrategy defaultValueStrategy) { return(ObjectFactory.Create <BindableDomainObjectPropertyReflector> ( true, ParamList.Create(propertyInfo, businessObjectProvider, domainModelConstraintProvider, defaultValueStrategy))); }
public override void SetUp() { base.SetUp(); _bindableObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory(); BusinessObjectProvider.SetProvider <BindableObjectProviderAttribute> (_bindableObjectProvider); BusinessObjectProvider.SetProvider <BindableObjectWithIdentityProviderAttribute> (_bindableObjectProvider); _mockRepository = new MockRepository(); _bindableObjectClass = BindableObjectProviderTestHelper.GetBindableObjectClass(typeof(SimpleBusinessObjectClass)); }
public void GetFromUniqueIdentifier() { BusinessObjectProvider.GetProvider <BindableDomainObjectProviderAttribute>().AddService(typeof(IGetObjectService), new BindableDomainObjectGetObjectService()); SampleBindableMixinDomainObject original = SampleBindableMixinDomainObject.NewObject(); var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(SampleBindableMixinDomainObject)); var boClass = (BindableObjectClassWithIdentity)provider.GetBindableObjectClass(typeof(SampleBindableMixinDomainObject)); Assert.That(boClass.GetObject(original.ID.ToString()), Is.SameAs(original)); }
public override void SetUp() { base.SetUp(); _dataSource = new BindableObjectDataSource(); _provider = new BindableObjectProvider(); BusinessObjectProvider.SetProvider(typeof(BindableObjectProviderAttribute), _provider); BusinessObjectProvider.SetProvider(typeof(BindableObjectWithIdentityProviderAttribute), _provider); }
public void GetBindableObjectClass_WithOpenGeneric() { var provider = (BindableObjectProvider)BindableObjectProvider.GetProvider(typeof(BindableObjectProviderAttribute)); Assert.That( () => provider.GetBindableObjectClass(typeof(GenericBindableObject <>)), Throws.ArgumentException.With.Message.EqualTo( "The type 'Remotion.ObjectBinding.UnitTests.TestDomain.GenericBindableObject`1' " + "is not a bindable object implementation. Open generic types are not supported.\r\nParameter name: type")); }
public override void SetUp() { base.SetUp(); _bindableObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory(); BusinessObjectProvider.SetProvider <BindableObjectProviderAttribute> (_bindableObjectProvider); BusinessObjectProvider.SetProvider <BindableObjectWithIdentityProviderAttribute> (_bindableObjectProvider); _bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>(); _mockRepository = new MockRepository(); }
private BooleanProperty CreateProperty( string propertyName, BindableObjectProvider provider = null, BindableObjectGlobalizationService bindableObjectGlobalizationService = null) { return(new BooleanProperty( GetPropertyParameters( GetPropertyInfo(typeof(ClassWithValueType <bool>), propertyName), provider ?? _businessObjectProvider, bindableObjectGlobalizationService: bindableObjectGlobalizationService))); }
public void Create_FromSingleProperty() { var provider = BindableObjectProvider.GetProviderForBindableObjectType(typeof(TypeOne)); var properties = new[] { provider.GetBindableObjectClass(typeof(TypeOne)).GetPropertyDefinition("TypeTwoValue") }; var path = StaticBusinessObjectPropertyPath.Create(properties); Assert.That(path.Properties, Is.EqualTo(properties)); Assert.That(path.Identifier, Is.EqualTo("TypeTwoValue")); }
public override void SetUp() { base.SetUp(); _mockRepository = new MockRepository(); _bindableObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory(); _bindableObjectWithIdentityProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory(); BusinessObjectProvider.SetProvider <BindableObjectProviderAttribute> (_bindableObjectProvider); BusinessObjectProvider.SetProvider <BindableObjectWithIdentityProviderAttribute> (_bindableObjectWithIdentityProvider); }