public void OnLoaded_CannotCauseSameObjectToBeLoadedInSubTx_WhileItIsLoadedIntoParent_InitiatedFromParent() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_order)) .WhenCalled( mi => { Assert.That(ClientTransaction.Current, Is.SameAs(ReadOnlyRootTransaction)); Assert.That( () => WriteableSubTransaction.EnsureDataAvailable(_order.ID), Throws.InvalidOperationException.With.Message.EqualTo( "It's not possible to load objects into a subtransaction while they are being loaded into a parent transaction: " + "'Order|5682f032-2f0b-494b-a31c-c97f02b89c36|System.Guid'.")); }); ReadOnlyRootTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckState(ReadOnlyRootTransaction, _order, StateType.Unchanged); CheckState(ReadOnlyMiddleTransaction, _order, StateType.NotLoadedYet); CheckState(WriteableSubTransaction, _order, StateType.NotLoadedYet); } }
public void PropertyValueReadInReadOnlyMiddleTransaction_WithoutLoading_IsAllowed() { WriteableSubTransaction.EnsureDataAvailable(_order1.ID); var value = ExecuteInReadOnlyMiddleTransaction(() => _order1.OrderNumber); Assert.That(value, Is.EqualTo(1)); }
public void RelationReadInReadOnlyMiddleTransaction_WithoutLoading_IsAllowed() { WriteableSubTransaction.EnsureDataComplete(_relationEndPointID); WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.Customer1); var customer = ExecuteInReadOnlyMiddleTransaction(() => _order1.Customer); Assert.That(customer.ID, Is.EqualTo(DomainObjectIDs.Customer1)); }
public void QueryInReadOnlyMiddleTransaction_WithoutLoading_IsAllowed() { WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.Order1); var resultSet = ExecuteInReadOnlyMiddleTransaction(() => QueryFactory.CreateLinqQuery <Order>().Where(obj => obj.OrderNumber == 1).ToList()); Assert.That(resultSet, Has.Count.EqualTo(1)); Assert.That(resultSet[0].ID, Is.EqualTo(DomainObjectIDs.Order1)); }
public void RelationReadInReadOnlyMiddleTransaction_IsAllowed_NoLoading() { WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.Order1); WriteableSubTransaction.EnsureDataComplete(_relationEndPointID); WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.OrderTicket1); var orderTicket = ExecuteInReadOnlyMiddleTransaction(() => _order1.OrderTicket); Assert.That(orderTicket.ID, Is.EqualTo(DomainObjectIDs.OrderTicket1)); }
public void RelationReadInReadOnlyMiddleTransaction_WithoutLoading_IsAllowed() { WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.Order1); WriteableSubTransaction.EnsureDataComplete(_relationEndPointID); WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.OrderItem1); WriteableSubTransaction.EnsureDataAvailable(DomainObjectIDs.OrderItem2); var orderItems = ExecuteInReadOnlyMiddleTransaction(() => _order1.OrderItems.ToList()); Assert.That(orderItems.Select(oi => oi.ID), Is.EquivalentTo(new[] { DomainObjectIDs.OrderItem1, DomainObjectIDs.OrderItem2 })); }
public void RollbackInReadOnlyMiddleTransaction_IsForbidden() { Assert.That(ReadOnlyRootTransaction.HasChanged(), Is.True); Assert.That(ReadOnlyMiddleTransaction.HasChanged(), Is.True); Assert.That(WriteableSubTransaction.HasChanged(), Is.True); CheckForbidden(() => ReadOnlyMiddleTransaction.Rollback(), "TransactionRollingBack"); Assert.That(ReadOnlyRootTransaction.HasChanged(), Is.True); Assert.That(ReadOnlyMiddleTransaction.HasChanged(), Is.True); Assert.That(WriteableSubTransaction.HasChanged(), Is.True); }
public void CommitInReadOnlyMiddleTransaction_IsForbidden() { Assert.That(ReadOnlyRootTransaction.HasChanged(), Is.True); Assert.That(ReadOnlyMiddleTransaction.HasChanged(), Is.True); Assert.That(WriteableSubTransaction.HasChanged(), Is.True); CheckForbidden(() => ReadOnlyMiddleTransaction.Commit(), "TransactionCommitting"); Assert.That(ReadOnlyRootTransaction.HasChanged(), Is.True); Assert.That(ReadOnlyMiddleTransaction.HasChanged(), Is.True); Assert.That(WriteableSubTransaction.HasChanged(), Is.True); }
public void OnLoaded_CannotDeleteObject() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { var expectedSpecificMessage = "Object 'Client|1627ade8-125f-4819-8e33-ce567c42b00c|System.Guid' cannot be deleted."; ExpectOnLoadedCalls( _order, mi => CheckForbiddenOperation(ReadOnlyRootTransaction, () => _client1.Delete(), _order, expectedSpecificMessage), mi => CheckForbiddenOperation(ReadOnlyMiddleTransaction, () => _client1.Delete(), _order, expectedSpecificMessage), mi => CheckForbiddenOperation(WriteableSubTransaction, () => _client1.Delete(), _order, expectedSpecificMessage)); WriteableSubTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckState(ReadOnlyRootTransaction, _client1, StateType.Unchanged); CheckState(ReadOnlyMiddleTransaction, _client1, StateType.Unchanged); CheckState(WriteableSubTransaction, _client1, StateType.Unchanged); } }
public void OnLoaded_CannotModifyThisObject_BidirectionalRelations() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { // Load _order, but trying to modify _order.OrderTicket would also modify _orderTicket1 var offendingObject = _orderTicket1; var offendingProperty = GetPropertyIdentifier(typeof(OrderTicket), "Order"); ExpectOnLoadedCalls( _order, mi => CheckForbiddenSetProperty(ReadOnlyRootTransaction, _order, _order, o => o.OrderTicket, null, offendingObject, offendingProperty), mi => CheckForbiddenSetProperty(ReadOnlyMiddleTransaction, _order, _order, o => o.OrderTicket, null, offendingObject, offendingProperty), mi => CheckForbiddenSetProperty(WriteableSubTransaction, _order, _order, o => o.OrderTicket, null, offendingObject, offendingProperty)); WriteableSubTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckProperty(ReadOnlyRootTransaction, _order, o => o.OrderTicket, expectedOriginalValue: _orderTicket1, expectedCurrentValue: _orderTicket1); CheckProperty(ReadOnlyMiddleTransaction, _order, o => o.OrderTicket, expectedOriginalValue: _orderTicket1, expectedCurrentValue: _orderTicket1); CheckProperty(WriteableSubTransaction, _order, o => o.OrderTicket, expectedOriginalValue: _orderTicket1, expectedCurrentValue: _orderTicket1); } }
public void OnLoaded_CanModifyThisObject_PropertyValues() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_order)) .WhenCalled(mi => CheckTransactionAndSetProperty(ReadOnlyRootTransaction, _order, o => o.OrderNumber, expectedValue: 1, newValue: 2)); _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_order)) .WhenCalled(mi => CheckTransactionAndSetProperty(ReadOnlyMiddleTransaction, _order, o => o.OrderNumber, expectedValue: 2, newValue: 3)); _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_order)) .WhenCalled(mi => CheckTransactionAndSetProperty(WriteableSubTransaction, _order, o => o.OrderNumber, expectedValue: 3, newValue: 4)); } WriteableSubTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckProperty(ReadOnlyRootTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 1, expectedCurrentValue: 2); CheckProperty(ReadOnlyMiddleTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 2, expectedCurrentValue: 3); CheckProperty(WriteableSubTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 3, expectedCurrentValue: 4); }
public void OnLoaded_CannotModifyOtherObject_UnidirectionalRelations() { // No load events for _location _location.SetLoadEventReceiver(null); using (_loadEventReceiverMock.GetMockRepository().Ordered()) { // Load _order, but try to modify _location ExpectOnLoadedCalls( _order, mi => CheckForbiddenSetProperty(ReadOnlyRootTransaction, _order, _location, l => l.Client, newValue: _client2), mi => CheckForbiddenSetProperty(ReadOnlyMiddleTransaction, _order, _location, l => l.Client, newValue: _client3), mi => CheckForbiddenSetProperty(WriteableSubTransaction, _order, _location, l => l.Client, newValue: _client4)); WriteableSubTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckProperty(ReadOnlyRootTransaction, _location, l => l.Client, expectedOriginalValue: _client1, expectedCurrentValue: _client1); CheckProperty(ReadOnlyMiddleTransaction, _location, l => l.Client, expectedOriginalValue: _client1, expectedCurrentValue: _client1); CheckProperty(WriteableSubTransaction, _location, l => l.Client, expectedOriginalValue: _client1, expectedCurrentValue: _client1); } }
public void OnLoaded_CannotModifyOtherObject_PropertyValues() { // No load events for _order _order.SetLoadEventReceiver(null); using (_loadEventReceiverMock.GetMockRepository().Ordered()) { // Load _location, but try to modify _order ExpectOnLoadedCalls( _location, mi => CheckForbiddenSetProperty(ReadOnlyRootTransaction, _location, _order, o => o.OrderNumber, newValue: 2), mi => CheckForbiddenSetProperty(ReadOnlyMiddleTransaction, _location, _order, o => o.OrderNumber, newValue: 3), mi => CheckForbiddenSetProperty(WriteableSubTransaction, _location, _order, o => o.OrderNumber, newValue: 4)); WriteableSubTransaction.EnsureDataAvailable(_location.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckProperty(ReadOnlyRootTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 1, expectedCurrentValue: 1); CheckProperty(ReadOnlyMiddleTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 1, expectedCurrentValue: 1); CheckProperty(WriteableSubTransaction, _order, o => o.OrderNumber, expectedOriginalValue: 1, expectedCurrentValue: 1); } }
public void OnLoaded_CanModifyThisObject_UnidirectionalRelations() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_location)) .WhenCalled(mi => CheckTransactionAndSetProperty(ReadOnlyRootTransaction, _location, l => l.Client, expectedValue: _client1, newValue: _client2)); _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_location)) .WhenCalled(mi => CheckTransactionAndSetProperty(ReadOnlyMiddleTransaction, _location, l => l.Client, expectedValue: _client2, newValue: _client3)); _loadEventReceiverMock .Expect(mock => mock.OnLoaded(_location)) .WhenCalled(mi => CheckTransactionAndSetProperty(WriteableSubTransaction, _location, l => l.Client, expectedValue: _client3, newValue: _client4)); } WriteableSubTransaction.EnsureDataAvailable(_location.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckProperty(ReadOnlyRootTransaction, _location, l => l.Client, expectedOriginalValue: _client1, expectedCurrentValue: _client2); CheckProperty(ReadOnlyMiddleTransaction, _location, l => l.Client, expectedOriginalValue: _client2, expectedCurrentValue: _client3); CheckProperty(WriteableSubTransaction, _location, l => l.Client, expectedOriginalValue: _client3, expectedCurrentValue: _client4); }
public void OnLoaded_CannotCreateObject() { using (_loadEventReceiverMock.GetMockRepository().Ordered()) { var expectedSpecificMessage = "An object of type 'Partner' cannot be created."; ExpectOnLoadedCalls( _order, mi => CheckForbiddenOperation(ReadOnlyRootTransaction, () => Partner.NewObject(), _order, expectedSpecificMessage), mi => CheckForbiddenOperation(ReadOnlyMiddleTransaction, () => Partner.NewObject(), _order, expectedSpecificMessage), mi => CheckForbiddenOperation(WriteableSubTransaction, () => Partner.NewObject(), _order, expectedSpecificMessage)); WriteableSubTransaction.EnsureDataAvailable(_order.ID); _loadEventReceiverMock.VerifyAllExpectations(); CheckNoDataLoadedForType(ReadOnlyRootTransaction); Assert.That( ClientTransactionTestHelper.GetIDataManager(ReadOnlyMiddleTransaction).DataContainers.All( dc => dc.DomainObjectType != typeof(ClassWithAllDataTypes))); Assert.That( ClientTransactionTestHelper.GetIDataManager(WriteableSubTransaction).DataContainers.All( dc => dc.DomainObjectType != typeof(ClassWithAllDataTypes))); } }
protected T ExecuteInWriteableSubTransaction <T> (Func <T> func) { return(WriteableSubTransaction.ExecuteInScope(func)); }
protected void ExecuteInWriteableSubTransaction(Action action) { WriteableSubTransaction.ExecuteInScope(action); }