public void UniqueIdentifier_ViaImplementation() // overriding UniqueIdentifier is not possbile in BindableDomainObjects
{
var wrapper = SampleBindableDomainObject.NewObject();
var implementation = BindableDomainObjectImplementation.Create(wrapper);
Assert.That(implementation.UniqueIdentifier, Is.EqualTo(wrapper.ID.ToString()));
}
public void DisplayName_ViaImplementation_Default()
{
var wrapper = SampleBindableDomainObject.NewObject();
var implementation = BindableDomainObjectImplementation.Create(wrapper);
Assert.That(implementation.DisplayName, Is.EqualTo(((IBusinessObject)wrapper).BusinessObjectClass.Identifier));
}
public void UniqueIdentifierViaImplementation()
{
var instance = SampleBindableDomainObject.NewObject();
var mixin = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance, typeof(BindableDomainObject), "_implementation");
Assert.That(mixin.UniqueIdentifier, Is.EqualTo(instance.ID.ToString()));
}
public void BaseUniqueIdentifier()
{
var wrapper = SampleBindableDomainObject.NewObject();
var implementation = BindableDomainObjectImplementation.Create(wrapper);
Assert.That(implementation.BaseUniqueIdentifier, Is.EqualTo(wrapper.ID.ToString()));
}
public void Implementation_IsInitialized()
{
var instance = SampleBindableDomainObject.NewObject();
var implementation = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance, "_implementation");
Assert.That(implementation.BusinessObjectClass, Is.Not.Null);
}
public void Create()
{
var wrapper = SampleBindableDomainObject.NewObject();
var mixin = BindableDomainObjectImplementation.Create(wrapper);
Assert.That(mixin.BusinessObjectClass, Is.Not.Null);
Assert.That(PrivateInvoke.GetNonPublicProperty(mixin, "Target"), Is.SameAs(wrapper));
}
public void SearchAvailableObjectsWithDifferentObject()
{
IBusinessObject[] businessObjects =
_property.SearchAvailableObjects(SampleBindableDomainObject.NewObject(), new DefaultSearchArguments(_stubbedQueryID));
Assert.That(businessObjects, Is.Not.Null);
Assert.That(businessObjects.Length > 0, Is.True);
}
public void Deserialization()
{
var wrapper = SampleBindableDomainObject.NewObject();
var mixin = BindableDomainObjectImplementation.Create(wrapper);
var deserializedData = Serializer.SerializeAndDeserialize(Tuple.Create(mixin, wrapper));
Assert.That(deserializedData.Item1.BusinessObjectClass, Is.Not.Null);
Assert.That(PrivateInvoke.GetNonPublicProperty(deserializedData.Item1, "Target"), Is.SameAs(deserializedData.Item2));
}
public void CanRead_BusinessObjectIsNull_ReturnsTrue()
{
var property = GetProperty(SampleBindableDomainObject.NewObject());
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
var result = strategy.CanRead(null, property);
Assert.That(result, Is.True);
}
public override void SetUp()
{
base.SetUp();
_service = new BindableDomainObjectGetObjectService();
_instance = SampleBindableDomainObject.NewObject();
_businessObjectClass = (BindableObjectClassWithIdentity)((IBusinessObject)_instance).BusinessObjectClass;
_id = ((IBusinessObjectWithIdentity)_instance).UniqueIdentifier;
}
public void CanRead_NotADomainObject_ReturnsTrue()
{
var instance = MockRepository.GenerateStub <IBusinessObject>();
var property = GetProperty(SampleBindableDomainObject.NewObject());
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
var result = strategy.CanRead(instance, property);
Assert.That(result, Is.True);
}
public void SetProperty()
{
var instance = SampleBindableDomainObject.NewObject(_implementationMock);
_implementationMock.Expect(mock => mock.SetProperty(_propertyFake, 174));
_implementationMock.Replay();
((IBusinessObject)instance).SetProperty(_propertyFake, 174);
_implementationMock.VerifyAllExpectations();
}
public void BusinessObjectClass()
{
var instance = SampleBindableDomainObject.NewObject(_implementationMock);
_implementationMock.Expect(mock => mock.BusinessObjectClass).Return(_businessObjectClassFake);
_implementationMock.Replay();
Assert.That(((IBusinessObject)instance).BusinessObjectClass, Is.SameAs(_businessObjectClassFake));
_implementationMock.VerifyAllExpectations();
}
public void UniqueIdentifier()
{
var instance = SampleBindableDomainObject.NewObject(_implementationMock);
_implementationMock.Expect(mock => mock.BaseUniqueIdentifier).Return("123");
_implementationMock.Replay();
Assert.That(((IBusinessObjectWithIdentity)instance).UniqueIdentifier, Is.EqualTo("123"));
_implementationMock.VerifyAllExpectations();
}
public void GetPropertyString()
{
var instance = SampleBindableDomainObject.NewObject(_implementationMock);
_implementationMock.Expect(mock => mock.GetPropertyString(_propertyFake, "gj")).Return("yay");
_implementationMock.Replay();
Assert.That(((IBusinessObject)instance).GetPropertyString(_propertyFake, "gj"), Is.EqualTo("yay"));
_implementationMock.VerifyAllExpectations();
}
public void DisplayName()
{
var instance = SampleBindableDomainObject.NewObject(_implementationMock);
_implementationMock.Expect(mock => mock.BaseDisplayName).Return("Philips");
_implementationMock.Replay();
Assert.That(instance.DisplayName, Is.EqualTo("Philips"));
_implementationMock.VerifyAllExpectations();
}
public override void SetUp()
{
base.SetUp();
_service = new BindableDomainObjectSearchAllService();
_persistedSampleObject1 = SampleBindableDomainObject.NewObject();
_persistedSampleObject2 = SampleBindableDomainObject.NewObject();
ClientTransaction.Current.Commit();
}
public void Serialization()
{
var instance = SampleBindableDomainObject.NewObject();
instance = Serializer.SerializeAndDeserialize(instance);
var implementation = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance, "_implementation");
Assert.That(implementation, Is.Not.Null);
Assert.That(implementation.BusinessObjectClass, Is.Not.Null);
Assert.That(implementation.BusinessObjectClass.TargetType, Is.SameAs(typeof(SampleBindableDomainObject)));
}
public void Reloading()
{
var instance1 = SampleBindableDomainObject.NewObject();
var implementation1 = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance1, "_implementation");
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
var instance2 = instance1.ID.GetObject <SampleBindableDomainObject> ();
var implementation2 = (BindableDomainObjectImplementation)PrivateInvoke.GetNonPublicField(instance2, "_implementation");
Assert.That(implementation2, Is.SameAs(implementation1));
}
}
public void CanRead_NewObject_ReturnsTrue()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
Assert.That(instance.State, Is.EqualTo(StateType.New));
var result = strategy.CanRead(instance, property);
Assert.That(result, Is.True);
}
public void IsDefaultDefault_StateIsNewAndPropertyHasNotBeenTouched()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IDefaultValueStrategy) new BindableDomainObjectDefaultValueStrategy();
Assert.That(instance.State, Is.EqualTo(StateType.New));
var result = strategy.IsDefaultValue(instance, property);
Assert.That(result, Is.True);
}
public void CanRead_InvalidObject_ReturnsFalse()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
LifetimeService.DeleteObject(instance.DefaultTransactionContext.ClientTransaction, instance);
Assert.That(instance.State, Is.EqualTo(StateType.Invalid));
var result = strategy.CanRead(instance, property);
Assert.That(result, Is.False);
}
public void CanRead_ChangedObject_ReturnsTrue()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
instance.Name = "new value";
Assert.That(instance.State, Is.EqualTo(StateType.Changed));
var result = strategy.CanRead(instance, property);
Assert.That(result, Is.True);
}
}
public void IsDefaultDefault_StateIsNotNew()
{
var instance = SampleBindableDomainObject.NewObject();
LifetimeService.DeleteObject(instance.DefaultTransactionContext.ClientTransaction, instance);
var property = GetProperty(instance);
var strategy = (IDefaultValueStrategy) new BindableDomainObjectDefaultValueStrategy();
Assert.That(instance.State, Is.Not.EqualTo(StateType.New));
var result = strategy.IsDefaultValue(instance, property);
Assert.That(result, Is.False);
}
public void CanWrite_UnchangedObject_ReturnsTrue()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyWriteAccessStrategy) new BindableDomainObjectPropertyWriteAccessStrategy();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
instance.EnsureDataAvailable();
Assert.That(instance.State, Is.EqualTo(StateType.Unchanged));
var result = strategy.CanWrite(instance, property);
Assert.That(result, Is.True);
}
}
public void CanRead_DeletedObject_ReturnsFalse()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope())
{
LifetimeService.DeleteObject(instance.DefaultTransactionContext.ClientTransaction, instance);
Assert.That(instance.State, Is.EqualTo(StateType.Deleted));
var result = strategy.CanRead(instance, property);
Assert.That(result, Is.False);
}
}
public void IsDefaultDefault_StateIsNewAndPropertyCannotBeResolved()
{
var strategy = (IDefaultValueStrategy) new BindableDomainObjectDefaultValueStrategy();
var instance = SampleBindableDomainObject.NewObject();
var propertyInformationStub = MockRepository.GenerateStub <IPropertyInformation> ();
propertyInformationStub.Stub(stub => stub.PropertyType).Return(typeof(bool));
propertyInformationStub.Stub(stub => stub.GetIndexParameters()).Return(new ParameterInfo[0]);
propertyInformationStub.Stub(stub => stub.DeclaringType).Return(TypeAdapter.Create(typeof(bool)));
propertyInformationStub.Stub(stub => stub.GetOriginalDeclaringType()).Return(TypeAdapter.Create(typeof(bool)));
var property = CreateProperty(propertyInformationStub);
var result = strategy.IsDefaultValue(instance, property);
Assert.That(result, Is.False);
}
public void IsPropertyAccessible_WithObjectsNotFoundException_ReturnsTrue()
{
var instance = SampleBindableDomainObject.NewObject();
var property = GetProperty(instance);
var strategy = (IBindablePropertyReadAccessStrategy) new BindableDomainObjectPropertyReadAccessStrategy();
var originalException = new ObjectsNotFoundException("The Message", new ObjectID[0], null);
BusinessObjectPropertyAccessException actualException;
var result = strategy.IsPropertyAccessException(instance, property, originalException, out actualException);
Assert.That(result, Is.True);
Assert.That(actualException, Is.Not.Null);
Assert.That(
actualException.Message,
Is.EqualTo(
"An ObjectsNotFoundException occured while getting the value of property 'Name' for business object with ID '" + instance.ID + "'."));
Assert.That(actualException.InnerException, Is.SameAs(originalException));
}
public void CreateImplementation()
{
var instance = SampleBindableDomainObject.NewObject();
Assert.That(PrivateInvoke.GetNonPublicField(instance, "_implementation"), Is.InstanceOf(typeof(BindableDomainObjectImplementation)));
}
