public void NewObject_InSubTransaction_AssociatesRootTransaction()
{
var subTransaction = _rootTransaction.CreateSubTransaction();
var order = subTransaction.ExecuteInScope(() => Order.NewObject());
Assert.That(order.RootTransaction, Is.SameAs(_rootTransaction));
Assert.That(order.TransactionContext[_rootTransaction].State, Is.EqualTo(StateType.Invalid));
}
public void AppendLeafTransaction_SetsLeafTransaction()
{
var subTransaction = _rootTransaction.CreateSubTransaction();
_hierarchy.AppendLeafTransaction(subTransaction);
Assert.That(_hierarchy.RootTransaction, Is.SameAs(_rootTransaction));
Assert.That(_hierarchy.LeafTransaction, Is.SameAs(subTransaction));
Assert.That(_hierarchy.ActiveTransaction, Is.SameAs(_rootTransaction));
}
public void CreateSubTransaction_OfSubTransaction()
{
ClientTransaction subTransaction1 = TestableClientTransaction.CreateSubTransaction();
ClientTransaction subTransaction2 = subTransaction1.CreateSubTransaction();
Assert.That(ClientTransactionTestHelper.GetPersistenceStrategy(subTransaction2), Is.TypeOf(typeof(SubPersistenceStrategy)));
}
public void Initialization_NonRootTransaction()
{
Assert.That(
() => new ObjectReferenceInitializationContext(_objectID, _rootTransaction.CreateSubTransaction(), _enlistedDomainObjectManagerMock),
Throws.ArgumentException.With.Message.EqualTo(
"The rootTransaction parameter must be passed a root transaction.\r\nParameter name: rootTransaction"));
}
public void GetObjects_UnloadedObjects_PropagatedToParent()
{
ClientTransaction parent = ClientTransaction.CreateRootTransaction();
ClientTransaction subTransaction = parent.CreateSubTransaction();
LifetimeService.GetObject(subTransaction, DomainObjectIDs.ClassWithAllDataTypes1, false); // preload ClassWithAllDataTypes
var extensionMock = MockRepository.GenerateMock <IClientTransactionExtension> ();
extensionMock.Stub(stub => stub.Key).Return("mock");
parent.Extensions.Add(extensionMock);
LifetimeService.GetObjects <DomainObject> (
subTransaction,
DomainObjectIDs.Order1,
DomainObjectIDs.ClassWithAllDataTypes1,
// this has already been loaded
DomainObjectIDs.Order3,
DomainObjectIDs.OrderItem1);
extensionMock.AssertWasCalled(mock => mock.ObjectsLoading(Arg.Is(parent),
Arg <ReadOnlyCollection <ObjectID> > .List.Equal(new[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3, DomainObjectIDs.OrderItem1 })));
extensionMock.AssertWasNotCalled(mock => mock.ObjectsLoading(Arg.Is(parent),
Arg <ReadOnlyCollection <ObjectID> > .List.ContainsAll(new[] { DomainObjectIDs.ClassWithAllDataTypes1 })));
}
public void GetState_Invalidated_AfterCommit()
{
var subTransaction = _transaction.CreateSubTransaction();
subTransaction.EnsureDataAvailable(_existingOrder.ID);
subTransaction.ExecuteInScope(() => _existingOrder.OrderNumber++);
var cachingListener = new DomainObjectStateCache(subTransaction);
var stateBeforeChange = cachingListener.GetState(_existingOrder.ID);
subTransaction.Commit();
var stateAfterChange = cachingListener.GetState(_existingOrder.ID);
Assert.That(stateBeforeChange, Is.EqualTo(StateType.Changed));
Assert.That(stateAfterChange, Is.EqualTo(StateType.Unchanged));
}
public static IDisposable MakeInactive(ClientTransaction inactiveTransaction)
{
var scope = inactiveTransaction.CreateSubTransaction().EnterNonDiscardingScope();
Assertion.IsFalse(ReferenceEquals(inactiveTransaction.ActiveTransaction, inactiveTransaction), "The transaction can no longer be active.");
return(scope);
}
private ClientTransaction CreateSubTransactionAndClearListeners(ClientTransaction parentTransaction)
{
var subTransaction = parentTransaction.CreateSubTransaction();
ClientTransactionTestHelper.ClearAllListeners(subTransaction);
InstallUnlockWatcher(subTransaction);
return(subTransaction);
}
public void OpeningScopeForLeafTransaction_AffectsCurrentTransaction()
{
using (_rootTransaction.CreateSubTransaction().EnterNonDiscardingScope())
{
Assert.That(ClientTransaction.Current, Is.SameAs(_rootTransaction.LeafTransaction));
ClientTransaction.Current.Discard();
}
using (_rootTransaction.CreateSubTransaction().EnterDiscardingScope())
{
Assert.That(ClientTransaction.Current, Is.SameAs(_rootTransaction.LeafTransaction));
}
using (_rootTransaction.CreateSubTransaction().EnterScope(AutoRollbackBehavior.Rollback))
{
Assert.That(ClientTransaction.Current, Is.SameAs(_rootTransaction.LeafTransaction));
}
}
public void RootTransaction()
{
ClientTransaction subTransaction1 = TestableClientTransaction.CreateSubTransaction();
ClientTransaction subTransaction2 = subTransaction1.CreateSubTransaction();
Assert.That(TestableClientTransaction.RootTransaction, Is.SameAs(TestableClientTransaction));
Assert.That(subTransaction1.RootTransaction, Is.SameAs(TestableClientTransaction));
Assert.That(subTransaction2.RootTransaction, Is.SameAs(TestableClientTransaction));
}
public void Item_UsesAssociatedActiveTransactionByDefault()
{
var indexer = new PropertyIndexer(_industrialSector);
var accessor1 = indexer["Remotion.Data.DomainObjects.UnitTests.TestDomain.IndustrialSector.Name"];
Assert.That(accessor1.ClientTransaction, Is.SameAs(_transaction));
var subTransaction = _transaction.CreateSubTransaction();
var accessor2 = indexer["Remotion.Data.DomainObjects.UnitTests.TestDomain.IndustrialSector.Name"];
Assert.That(accessor2.ClientTransaction, Is.SameAs(_transaction));
using (subTransaction.EnterDiscardingScope())
{
var accessor3 = indexer["Remotion.Data.DomainObjects.UnitTests.TestDomain.IndustrialSector.Name"];
Assert.That(accessor3.ClientTransaction, Is.SameAs(subTransaction));
}
}
public void SubTransactionsAlsoMixed()
{
using (MixinConfiguration.BuildFromActive().ForClass(typeof(ClientTransaction)).Clear().AddMixins(typeof(InvertingClientTransactionMixin)).EnterScope())
{
ClientTransaction mixedTransaction = ClientTransaction.CreateRootTransaction();
ClientTransaction mixedSubTransaction = mixedTransaction.CreateSubTransaction();
Assert.That(mixedSubTransaction, Is.Not.Null);
Assert.That(Mixin.Get <InvertingClientTransactionMixin> (mixedSubTransaction), Is.Not.Null);
}
}
public override void SetUp()
{
base.SetUp();
_rootTransaction = ClientTransaction.CreateRootTransaction();
_subTransaction = _rootTransaction.CreateSubTransaction();
_subTransaction.EnterDiscardingScope();
_orderReference = DomainObjectIDs.Order1.GetObjectReference <Order> (_rootTransaction);
}
public void IsSynchronized_CalledFromSubTransaction_UsesRootTransaction()
{
var endPointID = RelationEndPointID.Create(DomainObjectIDs.OrderItem1, typeof(OrderItem), "Order");
var endPointStub = MockRepository.GenerateStub <IRelationEndPoint> ();
endPointStub.Stub(stub => stub.ID).Return(endPointID);
endPointStub.Stub(stub => stub.Definition).Return(endPointID.Definition);
endPointStub.Stub(stub => stub.IsDataComplete).Return(true);
endPointStub.Stub(stub => stub.IsSynchronized).Return(true).Repeat.Once();
endPointStub.Stub(stub => stub.IsSynchronized).Return(false).Repeat.Once();
RelationEndPointManagerTestHelper.AddEndPoint(_relationEndPointManager, endPointStub);
var subTransaction = _transaction.CreateSubTransaction();
using (subTransaction.EnterDiscardingScope())
{
Assert.That(BidirectionalRelationSyncService.IsSynchronized(subTransaction, endPointID), Is.True);
Assert.That(BidirectionalRelationSyncService.IsSynchronized(subTransaction, endPointID), Is.False);
}
}
public override void SetUp()
{
base.SetUp();
_rootTransaction = ClientTransaction.CreateRootTransaction();
_middleTransaction = _rootTransaction.CreateSubTransaction();
_leafTransaction = _middleTransaction.CreateSubTransaction();
_order1LoadedInMiddleTransaction = DomainObjectIDs.Order1.GetObject <Order> (_middleTransaction);
_objectReferenceFromMiddleTransaction = DomainObjectIDs.Order3.GetObjectReference <Order> (_rootTransaction);
}
public void NewObject_WithSubTransaction()
{
var subTransaction = _transaction.CreateSubTransaction();
var agent = new ObjectLifetimeAgent(
subTransaction,
_eventSinkWithMock,
_invalidDomainObjectManagerMock,
_dataManagerMock,
_enlistedDomainObjectManagerMock,
_persistenceStrategyMock);
_eventSinkWithMock.Stub(mock => mock.RaiseNewObjectCreatingEvent(Arg <Type> .Is.Anything));
_persistenceStrategyMock.Stub(mock => mock.CreateNewObjectID(Arg <ClassDefinition> .Is.Anything)).Return(_objectID1);
_domainObjectCreatorMock
.Expect(mock => mock.CreateNewObject(Arg <IObjectInitializationContext> .Is.Anything, Arg.Is(ParamList.Empty), Arg.Is(subTransaction)))
.WhenCalled(mi => CheckInitializationContext <NewObjectInitializationContext> (mi.Arguments[0], _objectID1, _transaction))
.Return(_domainObject1);
agent.NewObject(_typeDefinitionWithCreatorMock, ParamList.Empty);
_domainObjectCreatorMock.VerifyAllExpectations();
}
public void CreateSubTransaction_SetsParentReadonly()
{
Assert.That(TestableClientTransaction.IsWriteable, Is.True);
ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();
Assert.That(TestableClientTransaction.IsWriteable, Is.False);
Assert.That(subTransaction.IsWriteable, Is.True);
ClientTransaction subTransaction2 = subTransaction.CreateSubTransaction();
Assert.That(subTransaction.IsWriteable, Is.False);
Assert.That(subTransaction2.IsWriteable, Is.True);
}
public void GetAccess_UsesSecurityFreeSection()
{
ClientTransaction subTransaction;
using (_clientTransaction.EnterNonDiscardingScope())
{
var abstractRoles = new List <IDomainObjectHandle <AbstractRoleDefinition> >();
//abstractRoles.Add (_ace.SpecificAbstractRole.GetHandle());
//_ace.GroupCondition = GroupCondition.AnyGroupWithSpecificGroupType;
//_ace.SpecificGroupType = GroupType.NewObject();
OrganizationalStructureFactory organizationalStructureFactory = new OrganizationalStructureFactory();
var role = Role.NewObject();
role.Group = organizationalStructureFactory.CreateGroup();
role.Group.Tenant = _tenant;
role.Position = organizationalStructureFactory.CreatePosition();
var token = SecurityToken.Create(PrincipalTestHelper.Create(_tenant, null, new[] { role }), null, null, null, abstractRoles);
subTransaction = _clientTransaction.CreateSubTransaction();
using (subTransaction.EnterNonDiscardingScope())
{
var aclHandle = CreateAccessControlListHandle();
Expect.Call(_mockAclFinder.Find(_context))
.WhenCalled(invocation => Assert.That(SecurityFreeSection.IsActive, Is.True))
.Return(aclHandle);
Expect.Call(_mockTokenBuilder.CreateToken(_principalStub, _context))
.WhenCalled(invocation => Assert.That(SecurityFreeSection.IsActive, Is.True))
.Return(token);
}
}
var serviceLocator = DefaultServiceLocator.Create();
serviceLocator.RegisterSingle(() => MockRepository.GenerateStub <ISecurityProvider>());
using (new ServiceLocatorScope(serviceLocator))
{
_clientTransaction.Extensions.Add(new SecurityClientTransactionExtension());
_mocks.ReplayAll();
_service.GetAccess(_context, _principalStub);
_mocks.VerifyAll();
}
}
public void ExecuteInScope_ForLeafTransaction_AffectsCurrentTransaction()
{
var subTransaction = _rootTransaction.CreateSubTransaction();
subTransaction.ExecuteInScope(() => Assert.That(ClientTransaction.Current, Is.SameAs(subTransaction)));
subTransaction.ExecuteInScope(
() =>
{
Assert.That(ClientTransaction.Current, Is.SameAs(subTransaction));
return(7);
});
}
public void LeafTransaction()
{
ClientTransaction subTransaction1 = TestableClientTransaction.CreateSubTransaction();
ClientTransaction subTransaction2 = subTransaction1.CreateSubTransaction();
Assert.That(TestableClientTransaction.LeafTransaction, Is.SameAs(subTransaction2));
Assert.That(subTransaction1.LeafTransaction, Is.SameAs(subTransaction2));
Assert.That(subTransaction2.LeafTransaction, Is.SameAs(subTransaction2));
subTransaction2.Discard();
Assert.That(TestableClientTransaction.LeafTransaction, Is.SameAs(subTransaction1));
Assert.That(subTransaction1.LeafTransaction, Is.SameAs(subTransaction1));
subTransaction1.Discard();
Assert.That(TestableClientTransaction.LeafTransaction, Is.SameAs(TestableClientTransaction));
}
public override void SetUp()
{
base.SetUp();
_leafRootTransaction = ClientTransaction.CreateRootTransaction();
_rootTransactionWithSub = ClientTransaction.CreateRootTransaction();
_leafSubTransaction = _rootTransactionWithSub.CreateSubTransaction();
_readOnlyTransaction = new TestableClientTransaction();
ClientTransactionTestHelper.SetIsWriteable(_readOnlyTransaction, false);
_mockRepository = new MockRepository();
_commandFactoryMock = _mockRepository.StrictMock <ICommandFactory>();
_commandMock1 = _mockRepository.StrictMock <IDataManagementCommand> ();
_commandMock2 = _mockRepository.StrictMock <IDataManagementCommand> ();
_executor = new TransactionHierarchyCommandExecutor(_commandFactoryMock.Create);
}
public void ActiveSubTansaction()
{
ClientTransaction subTransaction1 = TestableClientTransaction.CreateSubTransaction();
Assert.That(TestableClientTransaction.SubTransaction, Is.SameAs(subTransaction1));
ClientTransaction subTransaction2 = subTransaction1.CreateSubTransaction();
Assert.That(subTransaction1.SubTransaction, Is.SameAs(subTransaction2));
Assert.That(subTransaction2.SubTransaction, Is.Null);
subTransaction2.Discard();
Assert.That(subTransaction1.SubTransaction, Is.Null);
Assert.That(TestableClientTransaction.SubTransaction, Is.SameAs(subTransaction1));
subTransaction1.Discard();
Assert.That(TestableClientTransaction.SubTransaction, Is.Null);
}
public void AccessDenied_SubTransaction()
{
_securityProviderStub.Stub(mock => mock.GetAccess(_securityContextStub, _securityPrincipalStub)).Return(new AccessType[0]);
Assert.That(_clientTransaction.Extensions[SecurityClientTransactionExtension.DefaultKey], Is.Not.Null);
var subTransaction = _clientTransaction.CreateSubTransaction();
Assert.That(subTransaction.Extensions[SecurityClientTransactionExtension.DefaultKey], Is.Not.Null);
using (subTransaction.EnterDiscardingScope())
{
SecurableObject securableObject;
using (SecurityFreeSection.Activate())
{
securableObject = CreateSecurableObject(_securityContextFactoryStub, clientTransaction: subTransaction);
}
Dev.Null = securableObject.PropertyWithDefaultPermission;
}
}
public void ITransactionScope_IsActiveScope()
{
ClientTransaction clientTransaction = ClientTransaction.CreateRootTransaction();
try
{
ITransactionScope outerScope = clientTransaction.EnterDiscardingScope();
Assert.That(outerScope.IsActiveScope, Is.True);
using (ClientTransactionScope innerScope = clientTransaction.CreateSubTransaction().EnterDiscardingScope())
{
Assert.That(outerScope.IsActiveScope, Is.False);
Assert.That(((ITransactionScope)innerScope).IsActiveScope, Is.True);
}
Assert.That(outerScope.IsActiveScope, Is.True);
outerScope.Leave();
Assert.That(outerScope.IsActiveScope, Is.False);
}
finally
{
ClientTransactionScope.ResetActiveScope(); // for TearDown
}
}
/// <summary> Creates a new child transaction for the current transaction. </summary>
/// <returns>
/// A new instance of the of a type implementing <see cref="ITransaction"/> that has the creating transaction
/// as a parent.
/// </returns>
/// <exception cref="NotSupportedException">
/// Thrown if the method is invoked while <see cref="ITransaction.CanCreateChild"/> is <see langword="false"/>.
/// </exception>
public virtual ITransaction CreateChild()
{
return(_wrappedInstance.CreateSubTransaction().ToITransaction());
}
