コード例 #1
0
        public void RuleBasedTransactionAttributeToString()
        {
            RuleBasedTransactionAttribute source = new RuleBasedTransactionAttribute();

            source.PropagationBehavior       = TransactionPropagation.Supports;
            source.TransactionIsolationLevel = IsolationLevel.RepeatableRead;
            source.TransactionTimeout        = 10;
            source.ReadOnly = true;
            source.AddRollbackRule(new RollbackRuleAttribute("ArgumentException"));
            source.AddRollbackRule(new NoRollbackRuleAttribute("IllegalTransactionStateException"));

            TransactionAttributeEditor editor = new TransactionAttributeEditor();

            editor.SetAsText(source.ToString());
            ITransactionAttribute ta = editor.Value;

            Assert.AreEqual(source, ta);
            Assert.AreEqual(ta.PropagationBehavior, TransactionPropagation.Supports);
            Assert.AreEqual(ta.TransactionIsolationLevel, IsolationLevel.RepeatableRead);
            Assert.AreEqual(ta.TransactionTimeout, 10);
            Assert.IsTrue(ta.ReadOnly);
            Assert.IsTrue(ta.RollbackOn(new ArgumentException()));
            Assert.IsFalse(ta.RollbackOn(new IllegalTransactionStateException()));

            source.ClearRollbackRules();
            Assert.IsFalse(ta == source);
            source.AddRollbackRule(new RollbackRuleAttribute("ArgumentException"));
            source.AddRollbackRule(new NoRollbackRuleAttribute("IllegalTransactionStateException"));
            Assert.AreEqual(ta, source);
        }
コード例 #2
0
        public void DefaultTransactionAttributeToString()
        {
            DefaultTransactionAttribute source = new DefaultTransactionAttribute( );

            source.PropagationBehavior       = TransactionPropagation.Supports;
            source.TransactionIsolationLevel = IsolationLevel.RepeatableRead;
            source.TransactionTimeout        = 10;
            source.ReadOnly = true;

            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText(source.ToString( ));
            ITransactionAttribute ta = editor.Value;

            Assert.AreEqual(source, ta);
            Assert.AreEqual(ta.PropagationBehavior, TransactionPropagation.Supports);
            Assert.AreEqual(ta.TransactionIsolationLevel, IsolationLevel.RepeatableRead);
            Assert.AreEqual(ta.TransactionTimeout, 10);
            Assert.IsTrue(ta.ReadOnly);
            Assert.IsTrue(ta.RollbackOn(new SystemException( )));
            //mlp 3/17 changed rollback to rollback on all exceptions.
            Assert.IsTrue(ta.RollbackOn(new ApplicationException( )));

            source.TransactionTimeout = 9;
            Assert.IsFalse(ta == source);
            source.TransactionTimeout = 10;
            Assert.AreEqual(ta, source);
        }
コード例 #3
0
        public void RollbackRules()
        {
            TransactionInterceptor txInterceptor = ctx.GetObject("txRollbackAdvice") as TransactionInterceptor;

            Assert.IsNotNull(txInterceptor);

            MethodInfo getDescriptionMethod          = typeof(ITestObject).GetMethod("GetDescription");
            MethodInfo exceptionalMethod             = typeof(ITestObject).GetMethod("Exceptional");
            ITransactionAttributeSource txAttrSource = txInterceptor.TransactionAttributeSource;
            ITransactionAttribute       txAttr       = txAttrSource.ReturnTransactionAttribute(getDescriptionMethod, typeof(ITestObject));

            Assert.IsTrue(txAttr.RollbackOn(new System.ApplicationException()));

            txAttr = txAttrSource.ReturnTransactionAttribute(exceptionalMethod, typeof(ITestObject));
            Assert.IsFalse(txAttr.RollbackOn(new System.ArithmeticException()));
        }
コード例 #4
0
        public void ValidPropagationCodeAndIsolationCodeAndRollbackRules2()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("+DataException,readOnly,ISOLATION_READCOMMITTED,-RemotingException,PROPAGATION_SUPPORTS");
            ITransactionAttribute ta = editor.Value;

            Assert.IsNotNull(ta);
            Assert.IsTrue(ta.PropagationBehavior == TransactionPropagation.Supports);
            Assert.IsTrue(ta.TransactionIsolationLevel == IsolationLevel.ReadCommitted);
            Assert.IsTrue(ta.TransactionTimeout == -1);
            Assert.IsTrue(ta.ReadOnly);
            Assert.IsTrue(ta.RollbackOn(new SystemException( )));
            // Check for our bizarre customized rollback rules
            Assert.IsFalse(ta.RollbackOn(new DataException( )));
            Assert.IsTrue(ta.RollbackOn(new RemotingException( )));
        }
コード例 #5
0
        public void ValidPropagationCodeAndIsolationCodeAndRollbackRules1()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("PROPAGATION_MANDATORY,ISOLATION_REPEATABLEREAD,timeout_10,-DataException,+RemotingException");
            ITransactionAttribute ta = editor.Value;

            Assert.IsNotNull(ta);
            Assert.IsTrue(ta.PropagationBehavior == TransactionPropagation.Mandatory);
            Assert.IsTrue(ta.TransactionIsolationLevel == IsolationLevel.RepeatableRead);
            Assert.IsTrue(ta.TransactionTimeout == 10);
            Assert.IsFalse(ta.ReadOnly);
            Assert.IsTrue(ta.RollbackOn(new SystemException( )));
            // Check for our bizarre customized rollback rules
            Assert.IsTrue(ta.RollbackOn(new DataException( )));
            Assert.IsTrue(!ta.RollbackOn(new RemotingException( )));
        }
コード例 #6
0
 /// <summary>
 /// Decides if rollback is required for the supplied <paramref name="exception"/>.
 /// </summary>
 /// <param name="exception">The <see cref="System.Exception"/> to evaluate.</param>
 /// <returns>
 /// True if the exception causes a rollback, false otherwise.
 /// </returns>
 public bool RollbackOn(Exception exception)
 {
     return(targetAttribute.RollbackOn(exception));
 }