public void FinishTransport_FilterNew()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
transportedObjects.FinishTransport(transportedObject =>
{
Assert.That(transportedObject.State == StateType.New);
return(((ClassWithAllDataTypes)transportedObject).Int32Property < 0);
});
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
try
{
DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ();
Assert.Fail("Expected ObjectsNotFoundException");
}
catch (ObjectsNotFoundException)
{
// ok
}
ClassWithAllDataTypes c2 = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> ();
Assert.That(c2.Int32Property, Is.EqualTo(-2147483647));
}
}
public void FinishTransport_CallsCommit()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
var mockRepository = new MockRepository();
var extensionMock = mockRepository.StrictMock <IClientTransactionExtension>();
extensionMock.Expect(mock => mock.Committing(
Arg.Is(transportedObjects.DataTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(GetTransportedObjects(transportedObjects)),
Arg <ICommittingEventRegistrar> .Is.Anything));
extensionMock.Expect(mock => mock.CommitValidate(
Arg.Is(transportedObjects.DataTransaction),
Arg <ReadOnlyCollection <PersistableData> > .Matches(c => c.Select(d => d.DomainObject).SetEquals(GetTransportedObjects(transportedObjects)))));
extensionMock.Expect(mock => mock.Committed(
Arg.Is(transportedObjects.DataTransaction),
Arg <ReadOnlyCollection <DomainObject> > .List.Equivalent(GetTransportedObjects(transportedObjects))));
extensionMock.Expect(mock => mock.TransactionDiscard(transportedObjects.DataTransaction));
extensionMock.Stub(stub => stub.Key).Return("mock");
mockRepository.ReplayAll();
transportedObjects.DataTransaction.Extensions.Add(extensionMock);
transportedObjects.FinishTransport();
mockRepository.VerifyAll();
}
public void SpecialStrategy()
{
TransportItem[] items;
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
items = new[] { TransportItem.PackageDataContainer(DomainObjectIDs.Order1.GetObject <Order> ().InternalDataContainer) };
}
var repository = new MockRepository();
var strategyMock = repository.StrictMock <IImportStrategy>();
var streamFake = repository.Stub <Stream> ();
strategyMock.Expect(mock => mock.Import(streamFake)).Return(items);
strategyMock.Replay();
var importer = DomainObjectImporter.CreateImporterFromStream(streamFake, strategyMock);
TransportedDomainObjects result = importer.GetImportedObjects();
Assert.That(
result.TransportedObjects,
Is.EquivalentTo(LifetimeService.GetObjects <Order> (result.DataTransaction, DomainObjectIDs.Order1)));
strategyMock.VerifyAllExpectations();
}
public void FinishTransport_Twice()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
transportedObjects.FinishTransport(delegate { return(false); });
transportedObjects.FinishTransport();
}
public void EmptyTransport()
{
ClientTransaction dataTransaction = ClientTransaction.CreateRootTransaction();
var transportedObjects = new TransportedDomainObjects(dataTransaction, new List <DomainObject>());
Assert.That(transportedObjects.DataTransaction, Is.Not.Null);
Assert.That(transportedObjects.DataTransaction, Is.SameAs(dataTransaction));
Assert.That(GetTransportedObjects(transportedObjects), Is.Empty);
}
public void TransactionContainsMoreObjects_ThanAreTransported()
{
_transporter.LoadRecursive(DomainObjectIDs.Employee1, new FollowAllProcessNoneStrategy());
Assert.That(_transporter.ObjectIDs.Count, Is.EqualTo(0));
Assert.That(new List <ObjectID> (_transporter.ObjectIDs), Is.Empty);
TransportedDomainObjects transportedObjects = ExportAndLoadTransportData();
Assert.That(transportedObjects.TransportedObjects, Is.Empty);
}
public void FinishTransport_ClearsTransportedObjects()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
transportedObjects.FinishTransport(delegate { return(false); });
Assert.That(transportedObjects.DataTransaction, Is.Null);
Assert.That(transportedObjects.TransportedObjects, Is.Null);
}
public void FinishTransport_WithInactiveTTransaction()
{
var dataTransaction = ClientTransaction.CreateRootTransaction();
var transportedObjects = new TransportedDomainObjects(dataTransaction, new List <DomainObject>());
using (ClientTransactionTestHelper.MakeInactive(dataTransaction))
{
Assert.That(
() => transportedObjects.FinishTransport(),
Throws.TypeOf <ClientTransactionReadOnlyException>());
}
}
public void NonEmptyTransport_ObjectsBoundToTransaction()
{
var loadedIDs = new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.Company1 };
var data = DomainObjectTransporterTestHelper.GetBinaryDataFor(loadedIDs);
TransportedDomainObjects transportedObjects = DomainObjectTransporterTestHelper.Import(data);
foreach (DomainObject domainObject in transportedObjects.TransportedObjects)
{
Assert.That(domainObject.RootTransaction, Is.SameAs(transportedObjects.DataTransaction));
}
}
public void FinishTransport_DiscardsTransaction()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
var transaction = transportedObjects.DataTransaction;
transportedObjects.FinishTransport();
Assert.That(transaction.IsDiscarded, Is.True);
}
public void LoadTransportData_XmlStrategy()
{
_transporter.Load(DomainObjectIDs.Employee1);
_transporter.Load(DomainObjectIDs.Employee2);
TransportedDomainObjects transportedObjects = ExportAndLoadTransportData(XmlImportStrategy.Instance, XmlExportStrategy.Instance);
Assert.That(transportedObjects, Is.Not.Null);
var domainObjects = new List <DomainObject> (transportedObjects.TransportedObjects);
Assert.That(domainObjects.Count, Is.EqualTo(2));
Assert.That(domainObjects.ConvertAll(obj => obj.ID), Is.EquivalentTo(new[] { DomainObjectIDs.Employee1, DomainObjectIDs.Employee2 }));
}
public void TransportedObjectsStayConstant_WhenTransactionIsManipulated()
{
var transportedObjects = new TransportedDomainObjects(ClientTransaction.CreateRootTransaction(), new List <DomainObject>());
Assert.That(GetTransportedObjects(transportedObjects), Is.Empty);
using (transportedObjects.DataTransaction.EnterNonDiscardingScope())
{
DomainObjectIDs.Order1.GetObject <Order> ();
}
Assert.That(GetTransportedObjects(transportedObjects), Is.Empty);
}
public void FinishTransport_WithoutFilter()
{
TransportedDomainObjects transportedObjects = TransportAndDeleteObjects(
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
transportedObjects.FinishTransport();
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
ClassWithAllDataTypes c3 = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ();
ClassWithAllDataTypes c4 = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> ();
Assert.That(c3.Int32Property, Is.EqualTo(2147483647));
Assert.That(c4.Int32Property, Is.EqualTo(-2147483647));
}
}
public void NonEmptyTransport()
{
ClientTransaction newTransaction = ClientTransaction.CreateRootTransaction();
var transportedObjectList = new List <DomainObject>();
using (newTransaction.EnterNonDiscardingScope())
{
transportedObjectList.Add(DomainObjectIDs.Order1.GetObject <Order> ());
transportedObjectList.Add(DomainObjectIDs.Order3.GetObject <Order> ());
transportedObjectList.Add(DomainObjectIDs.Company1.GetObject <Company> ());
}
var transportedObjects = new TransportedDomainObjects(newTransaction, transportedObjectList);
Assert.That(transportedObjects.DataTransaction, Is.Not.Null);
Assert.IsNotEmpty(GetTransportedObjects(transportedObjects));
List <ObjectID> ids = GetTransportedObjects(transportedObjects).ConvertAll(obj => obj.ID);
Assert.That(ids, Is.EquivalentTo(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.Company1 }));
}
public void FinishTransport_FilterExisting()
{
TransportedDomainObjects transportedObjects = TransportAndChangeObjects(
typeof(ClassWithAllDataTypes).FullName + ".Int32Property",
42,
DomainObjectIDs.ClassWithAllDataTypes1,
DomainObjectIDs.ClassWithAllDataTypes2);
transportedObjects.FinishTransport(transportedObject =>
{
Assert.That(transportedObject.State == StateType.Changed);
return(((ClassWithAllDataTypes)transportedObject).BooleanProperty);
});
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
var c1 = DomainObjectIDs.ClassWithAllDataTypes1.GetObject <ClassWithAllDataTypes> ();
Assert.That(c1.Int32Property, Is.EqualTo(42));
var c2 = DomainObjectIDs.ClassWithAllDataTypes2.GetObject <ClassWithAllDataTypes> ();
Assert.That(c2.Int32Property, Is.Not.EqualTo(42));
}
}
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));
}
public static List <DomainObject> ImportObjects(byte[] binaryData)
{
TransportedDomainObjects transportedObjects = Import(binaryData);
return(new List <DomainObject> (transportedObjects.TransportedObjects));
}
private List <DomainObject> GetTransportedObjects(TransportedDomainObjects transportedObjects)
{
return(new List <DomainObject> (transportedObjects.TransportedObjects));
}
