public void DeleteInReadOnlyRootTransaction_IsForbidden_Loaded() { CheckState(ReadOnlyRootTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); CheckState(ReadOnlyMiddleTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); CheckState(WriteableSubTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); CheckForbidden(() => ExecuteInReadOnlyRootTransaction(() => _loadedClassWithAllDataTypes.Delete()), "ObjectDeleting"); CheckState(ReadOnlyRootTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); CheckState(ReadOnlyMiddleTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); CheckState(WriteableSubTransaction, _loadedClassWithAllDataTypes, StateType.Unchanged); }
public void InvalidStateType() { ClassWithAllDataTypes newObject = ClassWithAllDataTypes.NewObject(); DataContainer newObjectDataContainer = newObject.InternalDataContainer; ClassWithAllDataTypes loadedObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); DataContainer loadedObjectDataContainer = newObject.InternalDataContainer; Assert.That(newObject.IsInvalid, Is.False); Assert.That(newObject.State, Is.EqualTo(StateType.New)); Assert.That(loadedObject.IsInvalid, Is.False); Assert.That(loadedObject.State, Is.EqualTo(StateType.Unchanged)); newObject.Delete(); Assert.That(newObject.IsInvalid, Is.True); Assert.That(newObject.State, Is.EqualTo(StateType.Invalid)); Assert.That(newObjectDataContainer.IsDiscarded, Is.True); Assert.That(newObjectDataContainer.State, Is.EqualTo(StateType.Invalid)); loadedObject.Delete(); TestableClientTransaction.Commit(); Assert.That(loadedObject.IsInvalid, Is.True); Assert.That(loadedObject.State, Is.EqualTo(StateType.Invalid)); Assert.That(loadedObjectDataContainer.IsDiscarded, Is.True); Assert.That(loadedObjectDataContainer.State, Is.EqualTo(StateType.Invalid)); }
public void IsInvalid() { Assert.That(_loadedClassWithAllDataTypesMixin.IsInvalid, Is.EqualTo(_loadedClassWithAllDataTypes.IsInvalid)); Assert.That(_newClassWithAllDataTypesMixin.IsInvalid, Is.EqualTo(_newClassWithAllDataTypes.IsInvalid)); _newClassWithAllDataTypes.Delete(); Assert.That(_newClassWithAllDataTypesMixin.IsInvalid, Is.EqualTo(_newClassWithAllDataTypes.IsInvalid)); }
public void State() { Assert.That(_loadedClassWithAllDataTypesMixin.State, Is.EqualTo(_loadedClassWithAllDataTypes.State)); Assert.That(_newClassWithAllDataTypesMixin.State, Is.EqualTo(_newClassWithAllDataTypes.State)); ++_loadedClassWithAllDataTypes.Int32Property; Assert.That(_loadedClassWithAllDataTypesMixin.State, Is.EqualTo(_loadedClassWithAllDataTypes.State)); _loadedClassWithAllDataTypes.Delete(); Assert.That(_loadedClassWithAllDataTypesMixin.State, Is.EqualTo(_loadedClassWithAllDataTypes.State)); }
public void CommitRootNewSubDeleted() { ClassWithAllDataTypes obj = GetNewUnchanged(); Assert.That(obj.State, Is.EqualTo(StateType.New)); using (TestableClientTransaction.CreateSubTransaction().EnterDiscardingScope()) { obj.Delete(); Assert.That(obj.State, Is.EqualTo(StateType.Deleted)); ClientTransactionScope.CurrentTransaction.Commit(); } Assert.That(obj.State, Is.EqualTo(StateType.Invalid)); }
public void SubCommit_OfDeletedObject_DoesNotRaiseDeletedEvent() { using (_subTransaction.EnterDiscardingScope()) { ClassWithAllDataTypes domainObject = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); MockRepository repository = new MockRepository(); IClientTransactionExtension extensionMock = repository.StrictMock <IClientTransactionExtension>(); extensionMock.Stub(stub => stub.Key).Return("Mock"); extensionMock.Replay(); _subTransaction.Extensions.Add(extensionMock); try { extensionMock.BackToRecord(); extensionMock.ObjectDeleting(_subTransaction, domainObject); extensionMock.ObjectDeleted(_subTransaction, domainObject); repository.ReplayAll(); domainObject.Delete(); repository.VerifyAll(); repository.BackToRecordAll(); extensionMock.Committing(null, null, null); LastCall.IgnoreArguments(); extensionMock.CommitValidate(null, null); LastCall.IgnoreArguments(); extensionMock.Committed(null, null); LastCall.IgnoreArguments(); repository.ReplayAll(); _subTransaction.Commit(); repository.VerifyAll(); } finally { _subTransaction.Extensions.Remove("Mock"); } } }
public void CommitWithExistingObjectDeleted() { var clientTransactionEventReceiver = new ClientTransactionEventReceiver(TestableClientTransaction); ClassWithAllDataTypes classWithAllDataTypes = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); ObjectID classWithAllDataTypesID = classWithAllDataTypes.ID; classWithAllDataTypes.Delete(); TestableClientTransaction.Commit(); 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)); Assert.That(committingDomainObjects.Any(obj => obj.ID == classWithAllDataTypesID), Is.True); }
public void FinishTransport_FilterCalledForEachChangedObject() { var transporter = new DomainObjectTransporter(); transporter.Load(DomainObjectIDs.ClassWithAllDataTypes1); transporter.Load(DomainObjectIDs.ClassWithAllDataTypes2); transporter.Load(DomainObjectIDs.Order1); ModifyDatabase( delegate { ClassWithAllDataTypes c1 = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> (); ClassWithAllDataTypes c2 = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> (); c1.Delete(); c2.Delete(); }); TransportedDomainObjects transportedObjects = Transport(transporter); var expectedObjects = new List <DomainObject>(); using (transportedObjects.DataTransaction.EnterNonDiscardingScope()) { expectedObjects.Add(DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ()); expectedObjects.Add(DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> ()); } var filteredObjects = new List <DomainObject>(); transportedObjects.FinishTransport( delegate(DomainObject domainObject) { filteredObjects.Add(domainObject); return(true); }); Assert.That(filteredObjects, Is.EquivalentTo(expectedObjects)); }