Merge pull request #24 from ArturLavrov/feature-#23

Feature #23

Author: ArturLavrov

src/DeclarativeContracts.Tests/Postcondition/EnsureTests.cs

@@ -47,6 +47,29 @@ public void Ensure_ValidArgumentsAndContractViolated_ContractViolationExceptionT
                 )
             );
         }
+        
+        [Test]
+        public void Ensure_ValidArgumentsAndContractViolated_ContractViolationExceptionThrowsWithCustomMessage()
+        {
+            var customer = new Customer()
+            {
+                Name = null,
+                LastName = "Osbourne"
+            };
+
+            string contractViolationCustomMessage = "custom message";
+            
+            Assert.Throws
+            (
+                typeof(ContractViolationException),
+                () => Ensure.That(
+                    customer, 
+                    customer => customer.Name, 
+                    (name) => name != null,
+                    contractViolationCustomMessage
+                )
+            );
+        }
 
         [Test]
         public void Ensure_ValidArguemntsStringIsNotNull_ContractViolationExceptionDoesNotThrows()
@@ -103,5 +126,23 @@ public void That_PredicateRetursFalse_ThrowsContractViolationException()
 
             Assert.Throws(typeof(ContractViolationException), () => Ensure.That(customer.Name, (name) => name.Length > 10));
         }
+        
+        [Test]
+        public void That_PredicateRetursFalse_ThrowsContractViolationExceptionWithCustomMessage()
+        {
+            var customer = new Customer()
+            {
+                Name = "Ozzy",
+                LastName = "Osbourne"
+            };
+
+            string customContractViolationMessage = "custom message";
+            
+            Assert.Throws(typeof(ContractViolationException),
+                () => Ensure.That(
+                    customer.Name,
+                    (name) => name.Length > 10),
+                customContractViolationMessage);
+        }
     }
 }

src/DeclarativeContracts.Tests/Precondition/RequireTest.cs

@@ -9,6 +9,9 @@ namespace DeclarativeContracts.Tests.Precondition
     [TestFixture]
     public class RequireTest
     {
+        
+        
+        
         [Test]
         public void That_ValidArguemntsAndContractNotViolated_ContractViolationExceptionDoesNotThrows()
         {
@@ -46,6 +49,29 @@ public void That_ValidArguemntsAndContractViolated_ContractViolationExceptionThr
                     )
                 );
         }
+        
+        
+        [Test]
+        public void That_ValidArguemntsAndContractViolated_ContractViolationExceptionWithCustomTextThrows()
+        {
+            var customer = new Customer()
+            {
+                Name = null,
+                LastName = "Osbourne"
+            };
+
+            string contractViolationMessageText = "contract violation";
+            
+            Assert.Throws(
+                typeof(ContractViolationException),
+                () => Require.That(
+                    customer, 
+                    с => с.Name, 
+                    (name) => name != null,
+                    contractViolationMessageText
+                )
+            );
+        }
 
         [Test]
         public void That_CustomerNameSelectorIsNullPredicateNotNull_ArgumentExceptionThrows()
@@ -137,6 +163,26 @@ public void ForAll_ListWith3ElementsOneIsLessThanZero_ThrowsContractViolationExc
                 )
             );
         }
+        
+        [Test]
+        public void ForAll_ListWith3ElementsOneIsLessThanZero_ThrowsContractViolationExceptionWithCustomErrorMessage()
+        {
+            List<int> elementsCollection = new List<int>
+            {
+                -1,3,4
+            };
+
+            string contractViolationMessage = "contract was violated, custom message";
+            
+            Assert.Throws(
+                typeof(ContractViolationException),
+                () => Require.ForAll(
+                    elementsCollection,
+                    ((element) => element > 0),
+                    contractViolationMessage
+                )
+            );
+        }
 
         [Test]
         public void That_ContractViolatedPassCustomException_CustomExceptionWasThrows()
@@ -151,8 +197,7 @@ public void That_ContractViolatedPassCustomException_CustomExceptionWasThrows()
                 typeof(ArgumentException), 
                 () => Require.That(customer.Name, n => n.Length > 5, new ArgumentException()));
         }
-
-
+        
         [Test]
         public void That_TrueForAllElements_ReturnTrue()
         {
@@ -166,6 +211,20 @@ public void That_FalseForOneElementFromCollection_ContractViolationExceptionWasT
             var collection = new List<string>(){ "o", "World"};
             Assert.Throws(typeof(ContractViolationException), () => Require.TrueForAll(collection, (item) => item.Length > 2));
         }
+        
+        [Test]
+        public void That_FalseForOneElementFromCollection_ContractViolationExceptionWasThrownWithCustomErrorMessage()
+        {
+            var collection = new List<string>(){ "o", "World"};
+
+            string contractViolationMessage = "contract was violated, custom message";
+            
+            Assert.Throws(
+                typeof(ContractViolationException), 
+                () => Require.TrueForAll(collection, (item) => item.Length > 2),
+                contractViolationMessage
+            );
+        }
 
         [Test]
         public void That_PredicateForApplyIsNull_ArgumentExceptionWasThrown()

src/DeclarativeContracts/Postcondition/Ensure.cs

@@ -28,6 +28,27 @@ public static void That<TEntity, TMember>(TEntity entity, Func<TEntity, TMember>
                 throw new ContractViolationException("Contact postcondition was violated. Expected that predicate returns true.");
             }
         }
+
+        /// <summary>
+        ///  Method that verify element satisfied specified predicate
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="memberSelector"></param>
+        /// <param name="predicate"></param>
+        /// <param name="contractViolationMsg">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TEntity"></typeparam>
+        /// <typeparam name="TMember"></typeparam>
+        /// <returns></returns>
+        public static void That<TEntity, TMember>(TEntity entity, Func<TEntity, TMember> memberSelector, Predicate<TMember> predicate, string contractViolationMsg)
+        {
+            ArgumentChecker.CheckArgumentsNull(memberSelector, predicate);
+
+            var member = memberSelector.Invoke(entity);
+            if (!predicate(member))
+            {
+                throw new ContractViolationException(contractViolationMsg);
+            }
+        }
 
         /// <summary>
         /// Verify that verify element satisfied specified predicate
@@ -45,6 +66,23 @@ public static void That<TElement>(TElement element, Predicate<TElement> predicat
             }
         }
 
+        /// <summary>
+        /// Verify that verify element satisfied specified predicate
+        /// </summary>
+        /// <param name="element">Element that needs to be checked</param>
+        /// <param name="predicate">Predicate that checks selected member</param>
+        /// <param name="contractViolationMessage">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TElement">Element type to check</typeparam>
+        public static void That<TElement>(TElement element, Predicate<TElement> predicate, string contractViolationMessage)
+        {
+            ArgumentChecker.CheckArgumentsNull(predicate, predicate);
+
+            if (!predicate(element))
+            {
+                throw new ContractViolationException(contractViolationMessage);
+            }
+        }
+
         /// <summary>
         ///Verify that element satisfied specified predicate, and throw passed exception.
         /// </summary>

src/DeclarativeContracts/Precondition/Require/ForAll.cs

@@ -23,20 +23,23 @@ public static void ForAll<TElement>(IEnumerable<TElement> elementsSequence, Pred
         {
             ArgumentChecker.CheckArgumentsNull(predicate);
 
-            try
-            {
-                foreach (var element in elementsSequence)
-                {
-                    if(!predicate(element))
-                    {
-                        throw new ContractViolationException($"Contact was violated.Predicate for element {element} return false.");
-                    }
-                }
-            }
-            catch(Exception ex)
-            {
-                throw new ContractViolationException("Contact was violated because an unhandled exception occured.", ex);
-            }
+            InternalForAll(elementsSequence, predicate);
+        }
+
+        /// <summary>
+        /// Methods that checks whether all members of input sequence satisfy the predicate
+        /// </summary>
+        /// <param name="elementsSequence">Input sequence of elements</param>
+        /// <param name="predicate">Predicate that tests every element of sequence</param>
+        /// <param name="contractViolationMessage">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TElement">Element type</typeparam>
+        /// <exception cref="ContractViolationException"></exception>
+        /// <throws>Throws ContractViolationException if element does not satisfy predicate</throws>
+        public static void ForAll<TElement>(IEnumerable<TElement> elementsSequence, Predicate<TElement> predicate, string contractViolationMessage)
+        {
+            ArgumentChecker.CheckArgumentsNull(predicate);
+
+            InternalForAll(elementsSequence, predicate, contractViolationMessage);
         }
 
         /// <summary>
@@ -56,5 +59,51 @@ public static void TrueForAll<TElement>(IEnumerable<TElement> elementsSequence,
                 throw new ContractViolationException();
             }
         }
+
+        /// <summary>
+        /// Methods that checks whether predicate is true for all member of input sequence
+        /// </summary>
+        /// <param name="elementsSequence">Input sequence of elements</param>
+        /// <param name="predicate">Predicate that tests every element of sequence</param>
+        /// <param name="contractViolationMessage">Custom text that will be throw as an exception text</param>
+        /// <typeparam name="TElement">Element type</typeparam>
+        /// <exception cref="ContractViolationException"></exception>
+        /// <throws>Throws ContractViolationException if element does not satisfy predicate</throws>
+        public static void TrueForAll<TElement>(IEnumerable<TElement> elementsSequence, Predicate<TElement> predicate, string contractViolationMessage)
+        {
+            ArgumentChecker.CheckArgumentsNull(predicate);
+
+            if (elementsSequence.Any(element => !predicate(element)))
+            {
+                throw new ContractViolationException(contractViolationMessage);
+            }
+        }
+
+        private static void InternalForAll<TElement>(IEnumerable<TElement> elementsSequence, Predicate<TElement> predicate, string contractViolationMessage = null)
+        {
+            try
+            {
+                foreach (var element in elementsSequence)
+                {
+                    if(!predicate(element))
+                    {
+                        throw new ContractViolationException(contractViolationMessage ?? $"Contact was violated.Predicate for element {element} return false.");
+                    }
+                }
+            }
+            catch(Exception ex)
+            {
+                throw new ContractViolationException(contractViolationMessage ?? "Contact was violated because an unhandled exception occured.", ex);
+            }
+        }
+
+        public static void InternalTrueForAll<TElement>(IEnumerable<TElement> elementsSequence,
+            Predicate<TElement> predicate, string contractViolationMessage)
+        {
+            if (elementsSequence.Any(element => !predicate(element)))
+            {
+                throw new ContractViolationException(contractViolationMessage ?? "default message");
+            }
+        }
     }
 }