Exemplo n.º 1
0
        public void SubTransaction_CanBeUsedToCreateAndLoadNewObjects()
        {
            ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();

            using (subTransaction.EnterDiscardingScope())
            {
                Assert.That(ClientTransactionScope.CurrentTransaction, Is.SameAs(subTransaction));
                Order order = Order.NewObject();
                Assert.That(subTransaction.IsEnlisted(order), Is.True);
                Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);

                order.OrderNumber = 4711;
                Assert.That(order.OrderNumber, Is.EqualTo(4711));

                OrderItem item = OrderItem.NewObject();
                order.OrderItems.Add(item);
                Assert.That(order.OrderItems.Contains(item.ID), Is.True);

                Ceo ceo = DomainObjectIDs.Ceo1.GetObject <Ceo> ();
                Assert.That(ceo, Is.Not.Null);
                Assert.That(subTransaction.IsEnlisted(ceo), Is.True);
                Assert.That(TestableClientTransaction.IsEnlisted(ceo), Is.True);

                Assert.That(DomainObjectIDs.Company1.GetObject <Company> (), Is.SameAs(ceo.Company));
            }
        }
Exemplo n.º 2
0
        public void AutomaticCleanup_WhenDomainObjectCtorThrows_DoesNotRequireDeletePermissions()
        {
            _securityProviderStub.Stub(mock => mock.GetAccess(_securityContextStub, _securityPrincipalStub)).Return(new AccessType[0]);

            _functionalSecurityStrategyStub
            .Stub(
                mock => mock.HasAccess(
                    Arg.Is(typeof(SecurableObject)),
                    Arg.Is(_securityProviderStub),
                    Arg.Is(_securityPrincipalStub),
                    Arg <IReadOnlyList <AccessType> > .List.Equal(new[] { AccessType.Get(GeneralAccessTypes.Create) })))
            .Return(true);

            var             exception      = new Exception("Test.");
            SecurableObject throwingObject = null;

            Assert.That(
                () => CreateSecurableObject(
                    _securityContextFactoryStub,
                    action: obj =>
            {
                throwingObject = obj;
                throw exception;
            }),
                Throws.Exception.SameAs(exception));

            Assert.That(_clientTransaction.IsEnlisted(throwingObject), Is.False);
        }
Exemplo n.º 3
0
        public void DomainObjects_CreatedInParent_CanBeUsedInSubTransactions()
        {
            Order             order          = Order.NewObject();
            ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();

            Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
            Assert.That(subTransaction.IsEnlisted(order), Is.True);
        }
Exemplo n.º 4
0
        public void DomainObjects_LoadedInParent_CanBeUsedInSubTransactions()
        {
            Order             order          = DomainObjectIDs.Order1.GetObject <Order> ();
            ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();

            Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
            Assert.That(subTransaction.IsEnlisted(order), Is.True);
        }
Exemplo n.º 5
0
        public void DomainObjects_CreatedInSubTransaction_CanBeUsedInParent()
        {
            ClientTransaction subTransaction = TestableClientTransaction.CreateSubTransaction();

            using (subTransaction.EnterDiscardingScope())
            {
                Order order = Order.NewObject();
                Assert.That(subTransaction.IsEnlisted(order), Is.True);
                Assert.That(TestableClientTransaction.IsEnlisted(order), Is.True);
            }
        }
        public void GetObjectByNewIndependentTransaction()
        {
            ClientTransaction clientTransaction = ClientTransaction.CreateRootTransaction();

            using (clientTransaction.EnterDiscardingScope())
            {
                Order order = DomainObjectIDs.Order1.GetObject <Order> ();

                Assert.That(order.InternalDataContainer.ClientTransaction, Is.SameAs(clientTransaction));
                Assert.That(clientTransaction.IsEnlisted(order), Is.True);
            }
        }
Exemplo n.º 7
0
        public void MarkInvalid(DomainObject domainObject)
        {
            ArgumentUtility.CheckNotNull("domainObject", domainObject);

            // This uses IsEnlisted rather than a RootTransaction check because the DomainObject reference is used inside the ClientTransaction, and we
            // explicitly want to allow only objects enlisted in the transaction.
            if (!_clientTransaction.IsEnlisted(domainObject))
            {
                throw CreateClientTransactionsDifferException(
                          "Cannot mark DomainObject '{0}' invalid, because it belongs to a different ClientTransaction.",
                          domainObject.ID);
            }

            if (DataContainers[domainObject.ID] != null)
            {
                var message = string.Format("Cannot mark DomainObject '{0}' invalid because there is data registered for the object.", domainObject.ID);
                throw new InvalidOperationException(message);
            }

            _invalidDomainObjectManager.MarkInvalid(domainObject);
        }
 private void CheckDomainObject(
     DomainObject result,
     ClientTransaction expectedClientTransaction,
     ObjectID expectedID     = null,
     StateType?expectedState = null)
 {
     Assert.That(expectedClientTransaction.IsEnlisted(result), Is.True);
     if (expectedID != null)
     {
         Assert.That(result.ID, Is.EqualTo(expectedID));
     }
     if (expectedState != null)
     {
         Assert.That(expectedClientTransaction.ExecuteInScope(() => result.State), Is.EqualTo(expectedState));
     }
 }