/// <summary>
 /// Add a mapping.
 /// </summary>
 public void Add(string methodPattern, string txAttributeText)
 {
     TransactionAttributeEditor editor = new TransactionAttributeEditor();
     editor.SetAsText(txAttributeText);
     ITransactionAttribute txAttribute = editor.Value;
     AddTransactionMethod(methodPattern, txAttribute);
 }
        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 );
        }
		public void NullTest()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( null );
			ITransactionAttribute ta = editor.Value;
			Assert.IsNull( ta );
		}
        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);
        }
        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 );
        }
        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);
        }
		public void EmptyStringTest()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( String.Empty );
			ITransactionAttribute ta = editor.Value;
			Assert.IsNull( ta );
		}
		public void ValidPropagationCodeAndIsolationCode()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( "PROPAGATION_REQUIRED, ISOLATION_READUNCOMMITTED" );
			ITransactionAttribute ta = editor.Value;
			Assert.IsTrue( ta != null );
			Assert.IsTrue( ta.PropagationBehavior == TransactionPropagation.Required );
			Assert.IsTrue( ta.TransactionIsolationLevel == IsolationLevel.ReadUncommitted );
		}
        /// <summary>
        /// Add a mapping.
        /// </summary>
        public void Add(string methodPattern, string txAttributeText)
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor();

            editor.SetAsText(txAttributeText);
            ITransactionAttribute txAttribute = editor.Value;

            AddTransactionMethod(methodPattern, txAttribute);
        }
        public void EmptyStringTest()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText(String.Empty);
            ITransactionAttribute ta = editor.Value;

            Assert.IsNull(ta);
        }
        public void NullTest()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText(null);
            ITransactionAttribute ta = editor.Value;

            Assert.IsNull(ta);
        }
		public void ValidPropagationCodeOnly()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( "PROPAGATION_REQUIRED" );
			ITransactionAttribute ta = editor.Value;
			Assert.IsTrue( ta != null );
			Assert.IsTrue( ta.PropagationBehavior == TransactionPropagation.Required );
			Assert.IsTrue( ta.TransactionIsolationLevel == IsolationLevel.ReadCommitted );
			Assert.IsFalse( ta.ReadOnly );
		}
        /// <summary>
        /// Parses the given properties into a name/attribute map.
        /// </summary>
        /// <remarks>
        /// Expects method names as keys and string attributes definitions as values,
        /// parsable into <see cref="Spring.Transaction.Interceptor.ITransactionAttribute"/>
        /// instances via
        /// <see cref="Spring.Transaction.Interceptor.TransactionAttributeEditor"/>.
        /// </remarks>
        /// <param name="transactionAttributes">The properties of the transaction.</param>
        public void SetProperties(NameValueCollection transactionAttributes)
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor();

            foreach (string methodName in transactionAttributes.Keys)
            {
                string value = transactionAttributes[methodName];
                editor.SetAsText(value);
                AddTransactionMethod(methodName, editor.Value);
            }
        }
        public void ValidPropagationCodeAndIsolationCode()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("PROPAGATION_REQUIRED, ISOLATION_READUNCOMMITTED");
            ITransactionAttribute ta = editor.Value;

            Assert.IsTrue(ta != null);
            Assert.IsTrue(ta.PropagationBehavior == TransactionPropagation.Required);
            Assert.IsTrue(ta.TransactionIsolationLevel == IsolationLevel.ReadUncommitted);
        }
 /// <summary>
 /// Converts from string to ITransactionAttribute
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="culture">The culture.</param>
 /// <param name="val">The string value to convert</param>
 /// <returns>An ITransactionAttribute instance</returns>
 public override object ConvertFrom(
     ITypeDescriptorContext context, CultureInfo culture, object val)
 {
     if (val is string)
     {
         string value = val as string;
         TransactionAttributeEditor editor = new TransactionAttributeEditor();
         editor.SetAsText(value);
         return editor.Value;
     }
     return base.ConvertFrom(context, culture, val);
 }
 /// <summary>
 /// Converts from string to ITransactionAttribute
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="culture">The culture.</param>
 /// <param name="val">The string value to convert</param>
 /// <returns>An ITransactionAttribute instance</returns>
 public override object ConvertFrom(
     ITypeDescriptorContext context, CultureInfo culture, object val)
 {
     if (val is string)
     {
         string value = val as string;
         TransactionAttributeEditor editor = new TransactionAttributeEditor();
         editor.SetAsText(value);
         return(editor.Value);
     }
     return(base.ConvertFrom(context, culture, val));
 }
        public void ValidPropagationCodeOnly()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("PROPAGATION_REQUIRED");
            ITransactionAttribute ta = editor.Value;

            Assert.IsTrue(ta != null);
            Assert.IsTrue(ta.PropagationBehavior == TransactionPropagation.Required);
            Assert.IsTrue(ta.TransactionIsolationLevel == IsolationLevel.ReadCommitted);
            Assert.IsFalse(ta.ReadOnly);
        }
		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( ) ) );
		}
        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( )));
        }
        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( )));
        }
        /// <summary>
        /// Parses the input properties <see cref="System.String"/> into a valid
        /// <see cref="Spring.Transaction.Interceptor.ITransactionAttributeSource"/>
        /// instance
        /// </summary>
        /// <param name="attributeSource">The properties string to be parsed.</param>
        public void SetAsText(string attributeSource)
        {
            MethodMapTransactionAttributeSource source = new MethodMapTransactionAttributeSource();

            if (attributeSource == null || attributeSource.Length == 0)
            {
                _attributeSource = null;
            }
            else
            {
                PropertiesEditor           editor = new PropertiesEditor(attributeSource);
                TransactionAttributeEditor tae    = new TransactionAttributeEditor();

                foreach (string name in editor.Keys)
                {
                    string value = editor[name];
                    tae.SetAsText(value);
                    ITransactionAttribute transactionAttribute = tae.Value;
                    source.AddTransactionalMethod(name, transactionAttribute);
                }
            }
            _attributeSource = source;
        }
        public void ValidPropagationAndIsolationCodeAndInvalidRollbackRule()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("PROPAGATION_REQUIRED,ISOLATION_READUNCOMMITTED,XXX");
        }
		/// <summary>
		/// Parses the input properties <see cref="System.String"/> into a valid
		/// <see cref="Spring.Transaction.Interceptor.ITransactionAttributeSource"/>
		/// instance
		/// </summary>
		/// <param name="attributeSource">The properties string to be parsed.</param>
		public void SetAsText( string attributeSource )
		{
			MethodMapTransactionAttributeSource source = new MethodMapTransactionAttributeSource();
			if ( attributeSource == null || attributeSource.Length == 0 )
			{
				_attributeSource = null;
			} else
			{
				PropertiesEditor editor = new PropertiesEditor(attributeSource);
				TransactionAttributeEditor tae = new TransactionAttributeEditor();

				foreach ( string name in editor.Keys )
				{
					string value = editor[name];
					tae.SetAsText( value );
					ITransactionAttribute transactionAttribute = tae.Value;
					source.AddTransactionalMethod( name, transactionAttribute );
				}
			}
			_attributeSource = source;
		}
		public void ValidPropagationAndIsolationCodeAndInvalidRollbackRule()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( "PROPAGATION_REQUIRED,ISOLATION_READUNCOMMITTED,XXX" );
		}
		public void InvalidPropagationCodeOnly()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			editor.SetAsText( "INVALIDPROPAGATIONCODE" );
		}
		public void InvalidPropagationCodeOnly()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
			Assert.Throws<ArgumentException>(() => editor.SetAsText( "INVALIDPROPAGATIONCODE" ));
		}
        public void ValidPropagationAndIsolationCodeAndInvalidRollbackRule()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            Assert.Throws <ArgumentException>(() => editor.SetAsText("PROPAGATION_REQUIRED,ISOLATION_READUNCOMMITTED,XXX"));
        }
        public void InvalidPropagationCodeOnly()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            Assert.Throws <ArgumentException>(() => editor.SetAsText("INVALIDPROPAGATIONCODE"));
        }
		public void ValidPropagationAndIsolationCodeAndInvalidRollbackRule()
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor( );
            Assert.Throws<ArgumentException>(() => editor.SetAsText( "PROPAGATION_REQUIRED,ISOLATION_READUNCOMMITTED,XXX" ));
		}
		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( ) ) );
		}
		/// <summary>
		/// Parses the given properties into a name/attribute map.
		/// </summary>
		/// <remarks>
		/// Expects method names as keys and string attributes definitions as values,
		/// parsable into <see cref="Spring.Transaction.Interceptor.ITransactionAttribute"/> 
		/// instances via 
		/// <see cref="Spring.Transaction.Interceptor.TransactionAttributeEditor"/>.
		/// </remarks>
		/// <param name="transactionAttributes">The properties of the transaction.</param>
		public void SetProperties( NameValueCollection transactionAttributes )
		{
			TransactionAttributeEditor editor = new TransactionAttributeEditor();
			foreach ( string methodName in transactionAttributes.Keys )
			{
				string value = transactionAttributes[methodName];
				editor.SetAsText(value);
				AddTransactionMethod(methodName, editor.Value);
			}
		}
        public void InvalidPropagationCodeOnly()
        {
            TransactionAttributeEditor editor = new TransactionAttributeEditor( );

            editor.SetAsText("INVALIDPROPAGATIONCODE");
        }