public void GetDataManager()
{
var clientTransaction = new TestableClientTransaction();
var dataManager = DataManagementService.GetDataManager(clientTransaction);
Assert.That(dataManager, Is.SameAs(clientTransaction.DataManager));
}
protected DataContainer GetDataContainer(DomainObject domainObject)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
return(DataManagementService.GetDataManager(ClientTransaction.Current)
.GetDataContainerWithLazyLoad(domainObject.ID, true));
}
public void UnloadAll_Transactions()
{
TestableClientTransaction.EnsureDataAvailable(DomainObjectIDs.Order1);
EnsureEndPointLoadedAndComplete(_collectionEndPointID);
Assert.That(TestableClientTransaction.DataManager.DataContainers[DomainObjectIDs.Order1], Is.Not.Null);
Assert.That(TestableClientTransaction.DataManager.GetRelationEndPointWithoutLoading(_collectionEndPointID), Is.Not.Null);
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
var middleTransaction = ClientTransaction.Current;
middleTransaction.EnsureDataAvailable(DomainObjectIDs.Order3);
Assert.That(DataManagementService.GetDataManager(middleTransaction).DataContainers[DomainObjectIDs.Order3], Is.Not.Null);
using (middleTransaction.CreateSubTransaction().EnterDiscardingScope())
{
ClientTransaction.Current.EnsureDataAvailable(DomainObjectIDs.Order4);
Assert.That(DataManagementService.GetDataManager(ClientTransaction.Current).DataContainers[DomainObjectIDs.Order4], Is.Not.Null);
UnloadService.UnloadAll(middleTransaction);
Assert.That(DataManagementService.GetDataManager(ClientTransaction.Current).DataContainers[DomainObjectIDs.Order4], Is.Null);
Assert.That(DataManagementService.GetDataManager(middleTransaction).DataContainers[DomainObjectIDs.Order3], Is.Null);
Assert.That(TestableClientTransaction.DataManager.DataContainers[DomainObjectIDs.Order1], Is.Null);
}
}
}
public void GetState_Invalidated_AfterMarkInvalid()
{
var stateBeforeChange = _cachingListener.GetState(_notYetLoadedOrder.ID);
_transaction.ExecuteInScope(() => DataManagementService.GetDataManager(_transaction).MarkInvalid(_notYetLoadedOrder));
var stateAfterChange = _cachingListener.GetState(_notYetLoadedOrder.ID);
Assert.That(stateBeforeChange, Is.EqualTo(StateType.NotLoadedYet));
Assert.That(stateAfterChange, Is.EqualTo(StateType.Invalid));
}
protected void CheckEndPointExists(RelationEndPointID endPointID, bool shouldEndPointExist)
{
ArgumentUtility.CheckNotNull("endPointID", endPointID);
var endPoint = DataManagementService.GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(endPointID);
if (shouldEndPointExist)
{
Assert.That(endPoint, Is.Not.Null, "End point '{0}' does not exist.", endPointID);
}
else
{
Assert.That(endPoint, Is.Null, "End point '{0}' should not exist.", endPointID);
}
}
protected void CheckDataContainerExists(DomainObject domainObject, bool dataContainerShouldExist)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
var dataContainer = DataManagementService.GetDataManager(ClientTransaction.Current).DataContainers[domainObject.ID];
if (dataContainerShouldExist)
{
Assert.That(dataContainer, Is.Not.Null, "Data container '{0}' does not exist.", domainObject.ID);
}
else
{
Assert.That(dataContainer, Is.Null, "Data container '{0}' should not exist.", domainObject.ID);
}
}
private static bool UsePersistentProperty(DomainObject domainObject, PropertyInfo property)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
ArgumentUtility.CheckNotNull("property", property);
if (!ReflectionUtility.IsRelationType(property.PropertyType))
{
return(true);
}
var dataManager = DataManagementService.GetDataManager(domainObject.DefaultTransactionContext.ClientTransaction);
var endPointID = RelationEndPointID.Create(domainObject.ID, property.DeclaringType, property.Name);
var endPoint = dataManager.GetRelationEndPointWithLazyLoad(endPointID);
return(endPoint.IsDataComplete);
}
public void DataContainerMapUnregistering_IgnoresNonNewObjects()
{
var middleTopTransaction = CreateSubTransactionAndClearListeners(_rootTransaction);
var domainObject = middleTopTransaction.ExecuteInScope(() => DomainObjectIDs.Order1.GetObject <Order> ());
var dataContainer = DataManagementService.GetDataManager(middleTopTransaction).GetDataContainerWithoutLoading(domainObject.ID);
Assert.That(dataContainer, Is.Not.Null);
var middleBottomTransaction = CreateSubTransactionAndClearListeners(middleTopTransaction);
var subTransaction = CreateSubTransactionAndClearListeners(middleBottomTransaction);
_listener.DataContainerMapUnregistering(middleTopTransaction, dataContainer);
Assert.That(middleBottomTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
Assert.That(subTransaction.IsInvalid(DomainObjectIDs.Order1), Is.False);
}
protected void CheckVirtualEndPointExistsAndComplete(RelationEndPointID endPointID, bool shouldEndPointExist, bool shouldDataBeComplete)
{
ArgumentUtility.CheckNotNull("endPointID", endPointID);
CheckEndPointExists(endPointID, shouldEndPointExist);
if (shouldEndPointExist)
{
var endPoint = DataManagementService.GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(endPointID);
if (shouldDataBeComplete)
{
Assert.That(endPoint.IsDataComplete, Is.True, "End point '{0}' should have complete data.", endPoint.ID);
}
else
{
Assert.That(endPoint.IsDataComplete, Is.False, "End point '{0}' should not have complete data.", endPoint.ID);
}
}
}
public void DataContainerMapUnregistering_MarksNewObjectsInvalidInSubtransactions()
{
var middleTopTransaction = CreateSubTransactionAndClearListeners(_rootTransaction);
var domainObject = middleTopTransaction.ExecuteInScope(() => Order.NewObject());
var dataContainer = DataManagementService.GetDataManager(middleTopTransaction).GetDataContainerWithoutLoading(domainObject.ID);
Assert.That(dataContainer, Is.Not.Null);
var middleBottomTransaction = CreateSubTransactionAndClearListeners(middleTopTransaction);
var subTransaction = CreateSubTransactionAndClearListeners(middleBottomTransaction);
_listener.DataContainerMapUnregistering(middleTopTransaction, dataContainer);
Assert.That(middleBottomTransaction.IsInvalid(domainObject.ID), Is.True);
Assert.That(ClientTransactionTestHelper.CallGetInvalidObjectReference(middleBottomTransaction, domainObject.ID), Is.SameAs(domainObject));
Assert.That(subTransaction.IsInvalid(domainObject.ID), Is.True);
Assert.That(ClientTransactionTestHelper.CallGetInvalidObjectReference(subTransaction, domainObject.ID), Is.SameAs(domainObject));
}
public void UnloadVirtualEndPointAndItemData_IsAtomicWithinTransaction_WhenCollectionIsChanged()
{
var order1 = DomainObjectIDs.Order1.GetObject <Order> ();
var endPointID = RelationEndPointID.Resolve(order1, o => o.OrderItems);
var orderItemA = order1.OrderItems[0];
var orderItemB = order1.OrderItems[1];
// Change the collection, but not the items; we need to test this within a subtransaction because this is the only way to get the collection to
// change without changing items (or the collection reference, which doesn't influence unloadability).
using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
order1.OrderItems.Clear();
order1.OrderItems.Add(orderItemB);
order1.OrderItems.Add(orderItemA);
Assert.That(orderItemA.State, Is.EqualTo(StateType.Unchanged));
Assert.That(orderItemB.State, Is.EqualTo(StateType.Unchanged));
Assert.That(DataManagementService.GetDataManager(ClientTransaction.Current).GetRelationEndPointWithoutLoading(endPointID).HasChanged, Is.True);
Assert.That(order1.OrderItems.IsDataComplete, Is.True);
CheckDataContainerExists(orderItemA, true);
CheckDataContainerExists(orderItemB, true);
CheckVirtualEndPointExistsAndComplete(endPointID, true, true);
Assert.That(() => UnloadService.UnloadVirtualEndPointAndItemData(ClientTransaction.Current, endPointID), Throws.InvalidOperationException);
CheckDataContainerExists(orderItemA, true);
CheckDataContainerExists(orderItemB, true);
CheckVirtualEndPointExistsAndComplete(endPointID, true, true);
Assert.That(UnloadService.TryUnloadVirtualEndPointAndItemData(ClientTransaction.Current, endPointID), Is.False);
CheckDataContainerExists(orderItemA, true);
CheckDataContainerExists(orderItemB, true);
CheckVirtualEndPointExistsAndComplete(endPointID, true, true);
Assert.That(orderItemA.State, Is.Not.EqualTo(StateType.NotLoadedYet));
Assert.That(orderItemB.State, Is.Not.EqualTo(StateType.NotLoadedYet));
Assert.That(order1.OrderItems.IsDataComplete, Is.True);
}
}
public static IDataManager GetIDataManager(ClientTransaction clientTransaction)
{
return(DataManagementService.GetDataManager(clientTransaction));
}
private void CheckTransactionIsEmpty(ClientTransaction clientTransaction)
{
Assert.That(DataManagementService.GetDataManager(clientTransaction).DataContainers, Is.Empty);
Assert.That(DataManagementService.GetDataManager(clientTransaction).RelationEndPoints, Is.Empty);
}