public override void SetUp()
{
base.SetUp();
_orderHandle1 = DomainObjectIDs.Order1.GetHandle <Order>();
_orderHandle2 = DomainObjectIDs.Order2.GetHandle <Order> ();
_notFoundOrderHandle = new ObjectID(typeof(Order), Guid.NewGuid()).GetHandle <Order>();
_clientTransaction = ClientTransaction.CreateRootTransaction();
}
public override void SetUp()
{
base.SetUp();
DomainObjectsConfiguration.SetCurrent(TableInheritanceConfiguration.Instance.GetDomainObjectsConfiguration());
MappingConfiguration.SetCurrent(TableInheritanceConfiguration.Instance.GetMappingConfiguration());
ConfigurationWrapper.SetCurrent(null);
_transactionScope = ClientTransaction.CreateRootTransaction().EnterDiscardingScope();
}
public override void SetUp()
{
base.SetUp();
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
_filter = new AccessControlEntryPropertiesEnumerationValueFilter();
}
public void GetAllObjects_DifferentTransaction()
{
var transaction = ClientTransaction.CreateRootTransaction();
var result = _service.GetAllObjects(transaction, typeof(SampleBindableDomainObject));
Assert.That(transaction.IsEnlisted((DomainObject)result[0]), Is.True);
Assert.That(ClientTransaction.Current.IsEnlisted((DomainObject)result[0]), Is.False);
}
public void InsertRelatedObject_FailsWithItemFromOtherHierarchy()
{
using (_leafTransaction.EnterNonDiscardingScope())
{
var orderItemFromOtherHierarchy = ClientTransaction.CreateRootTransaction().ExecuteInScope(() => OrderItem.NewObject());
_order1LoadedInMiddleTransaction.OrderItems.Add(orderItemFromOtherHierarchy);
}
}
public void ManyToOneRelationToConcreteSingle()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
TIOrder order = DomainObjectIDs.Order.GetObject <TIOrder>();
Assert.That(order.Customer.ID, Is.EqualTo(DomainObjectIDs.Customer));
}
}
public override void SetUp ()
{
base.SetUp();
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
DatabaseFixtures dbFixtures = new DatabaseFixtures();
dbFixtures.CreateEmptyDomain();
}
public override void SetUp()
{
base.SetUp();
_transaction = ClientTransaction.CreateRootTransaction();
_industrialSector = _transaction.ExecuteInScope(() => IndustrialSector.NewObject());
_order = _transaction.ExecuteInScope(() => Order.NewObject());
}
public void GetRevision()
{
DatabaseFixtures dbFixtures = new DatabaseFixtures();
dbFixtures.CreateEmptyDomain();
Assert.That(ClientTransaction.CreateRootTransaction().QueryManager.GetScalar(Revision.GetGetRevisionQuery(new RevisionKey())), Is.Null);
}
public void CreateClientTransactionExtensions_SubTransaction()
{
var clientTransaction = ClientTransaction.CreateRootTransaction().CreateSubTransaction();
var result = _factory.CreateClientTransactionExtensions(clientTransaction);
Assert.That(result, Is.Empty);
}
public override void SetUp()
{
base.SetUp();
_rootTransaction = ClientTransaction.CreateRootTransaction();
_order1LoadedInRootTransaction = DomainObjectIDs.Order1.GetObject <Order> (_rootTransaction);
_objectReferenceFromRootTransaction = DomainObjectIDs.Order3.GetObjectReference <Order> (_rootTransaction);
}
private static void InitializeLinq()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Initializing Linq took {elapsed:ms} ms."))
QueryFactory.CreateLinqQuery <Tenant>();
}
}
private static void ExecuteFirstLinqQuery()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Executing first Linq query took {elapsed:ms} ms."))
QueryFactory.CreateLinqQuery <Position>().ToList();
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
DatabaseFixtures dbFixtures = new DatabaseFixtures();
dbFixtures.CreateAndCommitSecurableClassDefinitionWithStates(ClientTransaction.CreateRootTransaction());
}
public override void SetUp()
{
base.SetUp();
_orderID1 = DomainObjectIDs.Order1;
_objectID2 = DomainObjectIDs.Order2;
_notFoundObjectID = new ObjectID(typeof(Order), Guid.NewGuid());
_clientTransaction = ClientTransaction.CreateRootTransaction();
}
/// <summary>
/// Creates a new root transaction instance. This instance is not yet managed by a scope.
/// </summary>
/// <returns>A new root transaction.</returns>
public ITransaction CreateRootTransaction()
{
var transaction = ClientTransaction.CreateRootTransaction();
OnTransactionCreated(transaction);
return(transaction.ToITransaction());
}
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);
}
private void ModifyDatabase(Action changer)
{
SetDatabaseModifyable();
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
changer();
ClientTransaction.Current.Commit();
}
}
public void WxeTransactedFunctionNone()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
ClientTransactionScope originalScope = ClientTransactionScope.ActiveScope;
new CreateNoneTestTransactedFunction(originalScope).Execute(Context);
Assert.That(ClientTransactionScope.ActiveScope, Is.SameAs(originalScope));
}
}
public override void SetUp()
{
base.SetUp();
_mockRepository = new MockRepository();
_cloner = new DomainObjectCloner();
_contextMock = MockRepository.StrictMock <CloneContext>(Cloner);
_sourceTransaction = ClientTransaction.CreateRootTransaction();
_cloneTransaction = ClientTransaction.CreateRootTransaction();
}
public void TryInstall_Success()
{
var transaction = ClientTransaction.CreateRootTransaction();
var result = _extension.TryInstall(transaction);
Assert.That(result, Is.True);
Assert.That(transaction.Extensions, Has.Member(_extension));
}
public void ResetScope()
{
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.Not.Null);
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.True);
ClientTransactionScope.ResetActiveScope();
Assert.That(ClientTransactionScope.ActiveScope, Is.Null);
Assert.That(ClientTransactionScope.HasCurrentTransaction, Is.False);
}
private void ModifyAndCommitInOtherTransaction(ObjectID objectID)
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var domainObject = objectID.GetObject <ClassWithAllDataTypes> ();
++domainObject.Int32Property;
ClientTransaction.Current.Commit();
}
}
public bool GenerateAndExecuteQuery()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var query = _queryGenerator();
var recordCount = query.ToList().Count;
return(recordCount > 100);
}
}
public void CreateCloneHull_RegistersDataContainer()
{
var transaction = ClientTransaction.CreateRootTransaction();
_cloner.CloneTransaction = transaction;
var clone = _cloner.CreateCloneHull(_classWithAllDataTypes);
Assert.That(clone.GetInternalDataContainerForTransaction(transaction).ClientTransaction, Is.SameAs(transaction));
}
private void CleanupClientWithNonExistingParentClient(ObjectID clientID)
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
var client = clientID.GetObject <Client> ();
client.Delete();
ClientTransaction.Current.Commit();
}
}
public void ClientTransactionCanBeMixed()
{
using (MixinConfiguration.BuildFromActive().ForClass(typeof(ClientTransaction)).Clear().AddMixins(typeof(InvertingClientTransactionMixin)).EnterScope())
{
ClientTransaction mixedTransaction = ClientTransaction.CreateRootTransaction();
Assert.That(mixedTransaction, Is.Not.Null);
Assert.That(Mixin.Get <InvertingClientTransactionMixin> (mixedTransaction), Is.Not.Null);
}
}
public void CheckIfRightTransaction_Fails()
{
var order = Order.NewObject();
using (ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope())
{
DomainObjectCheckUtility.CheckIfRightTransaction(order, ClientTransaction.Current);
}
}
public override void SetUp()
{
base.SetUp();
_dataContainer = DataContainer.CreateNew(DomainObjectIDs.Order1);
_dataContainer.SetDomainObject(DomainObjectMother.CreateFakeObject <Order> (_dataContainer.ID));
ClientTransactionTestHelper.RegisterDataContainer(ClientTransaction.CreateRootTransaction(), _dataContainer);
_loadedObjectData = new AlreadyExistingLoadedObjectData(_dataContainer);
}
public void SubTransactionInitialize_AddsExtensionToSubTransaction()
{
var subTransaction = ClientTransaction.CreateRootTransaction();
_testHelper.AddExtension(_extension);
_extension.SubTransactionInitialize(_testHelper.Transaction, subTransaction);
Assert.That(subTransaction.Extensions[_extension.Key], Is.SameAs(_extension));
}