public void ModifyOtherObjectInClientTransactionCommitting() { _customer.Name = "New name"; TestableClientTransaction.Committing += ClientTransaction_CommittingForModifyOtherObjectInClientTransactionCommitting; Ceo ceo = _customer.Ceo; var ceoEventReceiver = new DomainObjectEventReceiver(ceo); var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); TestableClientTransaction.Commit(); Assert.That(ceoEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(ceoEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(2)); Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1)); var committingDomainObjectsForFirstCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[0]; var committingDomainObjectsForSecondCommit = clientTransactionEventReceiver.CommittingDomainObjectLists[1]; var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0]; Assert.That(committingDomainObjectsForFirstCommitEvent.Count, Is.EqualTo(1)); Assert.That(committingDomainObjectsForSecondCommit.Count, Is.EqualTo(1)); Assert.That(committedDomainObjects.Count, Is.EqualTo(2)); Assert.That(committingDomainObjectsForFirstCommitEvent.Contains(_customer), Is.True); Assert.That(committingDomainObjectsForFirstCommitEvent.Contains(ceo), Is.False); Assert.That(committingDomainObjectsForSecondCommit.Contains(_customer), Is.False); Assert.That(committingDomainObjectsForSecondCommit.Contains(ceo), Is.True); Assert.That(committedDomainObjects.Contains(_customer), Is.True); Assert.That(committedDomainObjects.Contains(ceo), Is.True); }
public void Events() { Order order = Order.NewObject(); OrderItem orderItem = OrderItem.NewObject(); DomainObjectEventReceiver orderEventReceiver = new DomainObjectEventReceiver(order); DomainObjectEventReceiver orderItemEventReceiver = new DomainObjectEventReceiver(orderItem); DomainObjectCollectionEventReceiver collectionEventReceiver = new DomainObjectCollectionEventReceiver( order.OrderItems); order.DeliveryDate = new DateTime(2010, 1, 1); order.OrderItems.Add(orderItem); Assert.That(orderEventReceiver.HasChangingEventBeenCalled, Is.True); Assert.That(orderEventReceiver.HasChangedEventBeenCalled, Is.True); Assert.That(orderEventReceiver.ChangingPropertyDefinition.PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.DeliveryDate")); Assert.That(orderEventReceiver.ChangedPropertyDefinition.PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.DeliveryDate")); Assert.That(orderEventReceiver.HasRelationChangingEventBeenCalled, Is.True); Assert.That(orderEventReceiver.HasRelationChangedEventBeenCalled, Is.True); Assert.That(orderEventReceiver.ChangingRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderItems")); Assert.That(orderEventReceiver.ChangedRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Order.OrderItems")); Assert.That(orderItemEventReceiver.HasRelationChangingEventBeenCalled, Is.True); Assert.That(orderItemEventReceiver.HasRelationChangedEventBeenCalled, Is.True); Assert.That(orderItemEventReceiver.ChangingRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderItem.Order")); Assert.That(orderItemEventReceiver.ChangedRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderItem.Order")); Assert.That(collectionEventReceiver.HasAddingEventBeenCalled, Is.True); Assert.That(collectionEventReceiver.HasAddedEventBeenCalled, Is.True); Assert.That(collectionEventReceiver.AddingDomainObject, Is.SameAs(orderItem)); Assert.That(collectionEventReceiver.AddedDomainObject, Is.SameAs(orderItem)); }
public void ModifyOtherObjectInDomainObjectCommitting() { var ceo = _customer.Ceo; _customer.Name = "New name"; _customer.Committing += (sender, e) => ceo.Name = "New CEO name"; var ceoEventReceiver = new DomainObjectEventReceiver(ceo); var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); TestableClientTransaction.Commit(); Assert.That(ceoEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(ceoEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(2)); Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1)); var committingDomainObjects1 = clientTransactionEventReceiver.CommittingDomainObjectLists[0]; var committingDomainObjects2 = clientTransactionEventReceiver.CommittingDomainObjectLists[1]; var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0]; Assert.That(committingDomainObjects1, Is.EqualTo(new[] { _customer })); Assert.That(committingDomainObjects2, Is.EqualTo(new[] { ceo })); Assert.That(committedDomainObjects, Is.EquivalentTo(new DomainObject[] { _customer, ceo })); }
public override void SetUp() { base.SetUp(); _supervisor = DomainObjectIDs.Employee1.GetObject <Employee> (); _subordinate = DomainObjectIDs.Employee2.GetObject <Employee> (); _supervisorEventReceiver = new DomainObjectEventReceiver(_supervisor); _subordinateEventReceiver = new DomainObjectEventReceiver(_subordinate); _subordinateCollectionEventReceiver = new DomainObjectCollectionEventReceiver(_supervisor.Subordinates); }
public void ModifyOtherObjects() { _customer.Name = "New name"; Ceo ceo = _customer.Ceo; ceo.Name = "New CEO name"; Order order = _customer.Orders[DomainObjectIDs.Order1]; IndustrialSector industrialSector = _customer.IndustrialSector; var ceoEventReceiver = new DomainObjectEventReceiver(ceo); var customerEventReceiver = new DomainObjectEventReceiver(_customer); var orderEventReceiver = new DomainObjectEventReceiver(order); var industrialSectorEventReceiver = new DomainObjectEventReceiver(industrialSector); var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); _customer.Committing += (sender, e) => order.OrderNumber = 1000; TestableClientTransaction.Committing += (sender1, args) => { var customer = (Customer)args.DomainObjects.SingleOrDefault(obj => obj.ID == DomainObjectIDs.Customer1); if (customer != null) { customer.IndustrialSector.Name = "New industrial sector name"; } }; TestableClientTransaction.Commit(); Assert.That(ceoEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(ceoEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(customerEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(customerEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(orderEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(orderEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(industrialSectorEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(industrialSectorEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(2)); Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1)); var committingDomainObjectsForFirstCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[0]; var committingDomainObjectsForSecondCommitEvent = clientTransactionEventReceiver.CommittingDomainObjectLists[1]; var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0]; Assert.That(committingDomainObjectsForFirstCommitEvent, Is.EquivalentTo(new DomainObject[] { _customer, ceo })); Assert.That(committingDomainObjectsForSecondCommitEvent, Is.EquivalentTo(new DomainObject[] { order, industrialSector })); Assert.That(committedDomainObjects, Is.EquivalentTo(new DomainObject[] { _customer, ceo, order, industrialSector })); }
public override void SetUp() { base.SetUp(); _order = DomainObjectIDs.Order1.GetObject <Order> (); _oldOrderTicket = _order.OrderTicket; _newOrderTicket = DomainObjectIDs.OrderTicket2.GetObject <OrderTicket> (); _oldOrderOfNewOrderTicket = DomainObjectIDs.Order2.GetObject <Order> (); _orderEventReceiver = new DomainObjectEventReceiver(_order); _oldOrderTicketEventReceiver = new DomainObjectEventReceiver(_oldOrderTicket); _newOrderTicketEventReceiver = new DomainObjectEventReceiver(_newOrderTicket); _oldOrderOfNewOrderTicketEventReceiver = new DomainObjectEventReceiver(_oldOrderOfNewOrderTicket); }
public void ChangeTrackingEvents() { Customer customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var eventReceiver = new DomainObjectEventReceiver(customer, false); customer.Name = "New name"; Assert.That(eventReceiver.HasChangingEventBeenCalled, Is.EqualTo(true)); Assert.That(eventReceiver.HasChangedEventBeenCalled, Is.EqualTo(true)); Assert.That(customer.Name, Is.EqualTo("New name")); Assert.That(eventReceiver.ChangingOldValue, Is.EqualTo("Kunde 1")); Assert.That(eventReceiver.ChangingNewValue, Is.EqualTo("New name")); Assert.That(eventReceiver.ChangedOldValue, Is.EqualTo("Kunde 1")); Assert.That(eventReceiver.ChangedNewValue, Is.EqualTo("New name")); }
public void Serialization_WithISerializable_IncludesEventHandlers() { ClassWithAllDataTypes instance = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); var eventReceiver = new DomainObjectEventReceiver(instance); var deserializedData = Serializer.SerializeAndDeserialize(Tuple.Create(instance, eventReceiver)); AssertEventRegistered(deserializedData.Item1, "RelationChanging", deserializedData.Item2, GetEventHandlerMethod(instance, "RelationChanging")); AssertEventRegistered(deserializedData.Item1, "RelationChanged", deserializedData.Item2, GetEventHandlerMethod(instance, "RelationChanged")); AssertEventRegistered(deserializedData.Item1, "PropertyChanging", deserializedData.Item2, GetEventHandlerMethod(instance, "PropertyChanging")); AssertEventRegistered(deserializedData.Item1, "PropertyChanged", deserializedData.Item2, GetEventHandlerMethod(instance, "PropertyChanged")); AssertEventRegistered(deserializedData.Item1, "Deleting", deserializedData.Item2, GetEventHandlerMethod(instance, "Deleting")); AssertEventRegistered(deserializedData.Item1, "Deleted", deserializedData.Item2, GetEventHandlerMethod(instance, "Deleted")); AssertEventRegistered(deserializedData.Item1, "Committing", deserializedData.Item2, GetEventHandlerMethod(instance, "Committing")); AssertEventRegistered(deserializedData.Item1, "Committed", deserializedData.Item2, GetEventHandlerMethod(instance, "Committed")); AssertEventRegistered(deserializedData.Item1, "RollingBack", deserializedData.Item2, GetEventHandlerMethod(instance, "RollingBack")); AssertEventRegistered(deserializedData.Item1, "RolledBack", deserializedData.Item2, GetEventHandlerMethod(instance, "RolledBack")); }
public void CancelChangeTrackingEvents() { Customer customer = DomainObjectIDs.Customer1.GetObject <Customer> (); var eventReceiver = new DomainObjectEventReceiver(customer, true); try { customer.Name = "New name"; Assert.Fail("EventReceiverCancelException should be raised."); } catch (EventReceiverCancelException) { Assert.That(eventReceiver.HasChangingEventBeenCalled, Is.EqualTo(true)); Assert.That(eventReceiver.HasChangedEventBeenCalled, Is.EqualTo(false)); Assert.That(customer.Name, Is.EqualTo("Kunde 1")); Assert.That(eventReceiver.ChangingOldValue, Is.EqualTo("Kunde 1")); Assert.That(eventReceiver.ChangingNewValue, Is.EqualTo("New name")); } }
public void CommittedEventForObjectChangedBackToOriginal() { _customer.Name = "New name"; var customerEventReceiver = new DomainObjectEventReceiver(_customer); var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); _customer.Committing += (sender, e) => { _customer.Name = _customer.Properties[typeof(Company), "Name"].GetOriginalValue <string>(); }; TestableClientTransaction.Commit(); Assert.That(customerEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(customerEventReceiver.HasCommittedEventBeenCalled, Is.False); Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(1)); Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1)); var committingDomainObjects = clientTransactionEventReceiver.CommittingDomainObjectLists[0]; var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0]; Assert.That(committingDomainObjects.Count, Is.EqualTo(1)); Assert.That(committedDomainObjects.Count, Is.EqualTo(0)); }
public void CommitEvents() { _customer.Name = "New name"; var domainObjectEventReceiver = new DomainObjectEventReceiver(_customer); var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); TestableClientTransaction.Commit(); Assert.That(domainObjectEventReceiver.HasCommittingEventBeenCalled, Is.True); Assert.That(domainObjectEventReceiver.HasCommittedEventBeenCalled, Is.True); Assert.That(clientTransactionEventReceiver.CommittingDomainObjectLists.Count, Is.EqualTo(1)); Assert.That(clientTransactionEventReceiver.CommittedDomainObjectLists.Count, Is.EqualTo(1)); var committingDomainObjects = clientTransactionEventReceiver.CommittingDomainObjectLists[0]; var committedDomainObjects = clientTransactionEventReceiver.CommittedDomainObjectLists[0]; Assert.That(committingDomainObjects.Count, Is.EqualTo(1)); Assert.That(committedDomainObjects.Count, Is.EqualTo(1)); Assert.That(committingDomainObjects[0], Is.SameAs(_customer)); Assert.That(committedDomainObjects[0], Is.SameAs(_customer)); }
public void AddSubordinateWithOldSupervisor() { Employee subordinate = DomainObjectIDs.Employee3.GetObject <Employee> (); Employee oldSupervisorOfSubordinate = DomainObjectIDs.Employee2.GetObject <Employee> (); var subordinateEventReceiver = new DomainObjectEventReceiver(subordinate); subordinateEventReceiver.Cancel = false; var oldSupervisorEventReceiver = new DomainObjectEventReceiver(oldSupervisorOfSubordinate); oldSupervisorEventReceiver.Cancel = false; var oldSupervisorSubordinateCollectionEventReceiver = new DomainObjectCollectionEventReceiver(oldSupervisorOfSubordinate.Subordinates); oldSupervisorSubordinateCollectionEventReceiver.Cancel = false; _subordinateCollectionEventReceiver.Cancel = false; _supervisorEventReceiver.Cancel = false; _supervisor.Subordinates.Add(subordinate); Assert.That(oldSupervisorEventReceiver.HasRelationChangingEventBeenCalled, Is.True); Assert.That(oldSupervisorEventReceiver.HasRelationChangedEventBeenCalled, Is.True); Assert.That(oldSupervisorEventReceiver.ChangingRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Subordinates")); Assert.That(oldSupervisorEventReceiver.ChangedRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Subordinates")); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.HasRemovingEventBeenCalled, Is.True); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.HasRemovedEventBeenCalled, Is.True); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.RemovingDomainObjects.Count, Is.EqualTo(1)); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.RemovingDomainObjects[0], Is.SameAs(subordinate)); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.RemovingDomainObjects.Count, Is.EqualTo(1)); Assert.That(oldSupervisorSubordinateCollectionEventReceiver.RemovingDomainObjects[0], Is.SameAs(subordinate)); Assert.That(subordinateEventReceiver.HasRelationChangingEventBeenCalled, Is.True); Assert.That(subordinateEventReceiver.HasRelationChangedEventBeenCalled, Is.True); Assert.That(subordinateEventReceiver.ChangingRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Supervisor")); Assert.That(subordinateEventReceiver.ChangedRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Supervisor")); Assert.That(subordinateEventReceiver.ChangingOldRelatedObject, Is.SameAs(oldSupervisorOfSubordinate)); Assert.That(subordinateEventReceiver.ChangingNewRelatedObject, Is.SameAs(_supervisor)); Assert.That(subordinateEventReceiver.ChangedOldRelatedObject, Is.SameAs(oldSupervisorOfSubordinate)); Assert.That(subordinateEventReceiver.ChangedNewRelatedObject, Is.SameAs(_supervisor)); Assert.That(_subordinateCollectionEventReceiver.HasAddingEventBeenCalled, Is.True); Assert.That(_subordinateCollectionEventReceiver.HasAddedEventBeenCalled, Is.True); Assert.That(_subordinateCollectionEventReceiver.AddingDomainObject, Is.SameAs(subordinate)); Assert.That(_subordinateCollectionEventReceiver.AddedDomainObject, Is.SameAs(subordinate)); Assert.That(_supervisorEventReceiver.HasRelationChangingEventBeenCalled, Is.True); Assert.That(_supervisorEventReceiver.HasRelationChangedEventBeenCalled, Is.True); Assert.That(_supervisorEventReceiver.ChangingRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Subordinates")); Assert.That(_supervisorEventReceiver.ChangedRelationPropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.TestDomain.Employee.Subordinates")); Assert.That(_supervisorEventReceiver.ChangingOldRelatedObject, Is.Null); Assert.That(_supervisorEventReceiver.ChangingNewRelatedObject, Is.SameAs(subordinate)); Assert.That(_supervisorEventReceiver.ChangedOldRelatedObject, Is.Null); Assert.That(_supervisorEventReceiver.ChangedNewRelatedObject, Is.SameAs(subordinate)); Assert.That(subordinate.State, Is.EqualTo(StateType.Changed)); Assert.That(_supervisor.State, Is.EqualTo(StateType.Changed)); Assert.That(oldSupervisorOfSubordinate.State, Is.EqualTo(StateType.Changed)); Assert.That(_supervisor.Subordinates[subordinate.ID], Is.Not.Null); Assert.That(_supervisor.Subordinates.IndexOf(subordinate), Is.EqualTo(_supervisor.Subordinates.Count - 1)); Assert.That(oldSupervisorOfSubordinate.Subordinates.ContainsObject(subordinate), Is.False); Assert.That(subordinate.Supervisor, Is.SameAs(_supervisor)); }