code snippets for "Testing Exceptions" post

s1.cs

    public class Order
    {
        public IEnumerable<OrderLine> OrderLines { get; set; }
        public Customer Customer { get; set; }
 
        public Order() : this(null, null) {}
 
        public Order(Customer customer) : this(customer, null) {}
 
        public Order(Customer customer, IEnumerable<OrderLine> orderLines)
        {
            Customer = customer;
            OrderLines = orderLines;
        }
 
        public decimal CalculateTotal()
        {
            return OrderLines.Sum(o => o.Price) * Customer.DiscountRate;
        }
    }

s2.cs

    public enum OrderValidationProblem
    {
        OrderLinesNotSet,
        OrderLinesHasNoItems,
        CustomerNotSet
    }

s3.cs

    public class OrderValidationException : Exception
    {
        public OrderValidationProblem Problem { get; set; }
 
        public OrderValidationException(OrderValidationProblem problem)
        {
            Problem = problem;
        }
    }

s4.cs

    [TestFixture]
    public class OrderValidationTests
    {
        [Test]
        [ExpectedException(typeof(OrderValidationException))]
        public void CustomerNotSetThrowsValidationException()
        {
            var order = new Order();
            order.OrderLines = EntityTestFactory.CreateDummyOrderLines();
            order.CalculateTotal();
        }
 
        [Test]
        [ExpectedException(typeof(OrderValidationException))]
        public void OrderLinesNotSetThrowsValidationException()
        {
            var order = new Order(new Customer());
            order.CalculateTotal();
        }
 
        [Test]
        [ExpectedException(typeof(OrderValidationException))]
        public void OrderLinesWithNoItemsThrowsValidationException()
        {
            var order = new Order(new Customer(), new OrderLine[] {});
            order.CalculateTotal();
        }
    }

s5.cs

        public decimal CalculateTotal()
        {
            if (OrderLines == null) throw new OrderValidationException(OrderValidationProblem.OrderLinesNotSet);
            if (OrderLines.Count() == 0) throw new OrderValidationException(OrderValidationProblem.OrderLinesHasNoItems);
            if (Customer == null) throw new OrderValidationException(OrderValidationProblem.CustomerNotSet);
 
            return OrderLines.Sum(o => o.Price) * Customer.DiscountRate;
        }

s6.cs

        private void CheckExceptionAndProblem(Func<Decimal> function,
            OrderValidationProblem expectedOrderValidationProblem)
        {
            try
            {
                function();
            }
            catch (OrderValidationException e)
            {
                Assert.AreEqual(expectedOrderValidationProblem, e.Problem);
                return;
            }
            Assert.Fail("Exception was not thrown");
        }

s7.cs

        [Test]
        public void CustomerNotSetThrowsValidationException()
        {
            var order = new Order();
            order.OrderLines = EntityTestFactory.CreateDummyOrderLines();
            CheckExceptionAndProblem(order.CalculateTotal, OrderValidationProblem.CustomerNotSet);
        }
 
        [Test]
        public void OrderLinesNotSetThrowsValidationException()
        {
            var order = new Order(new Customer());
            CheckExceptionAndProblem(order.CalculateTotal, OrderValidationProblem.OrderLinesNotSet);
        }
 
        [Test]
        public void OrderLinesWithNoItemsThrowsValidationException()
        {
            var order = new Order(new Customer(), new OrderLine[] {});
            CheckExceptionAndProblem(order.CalculateTotal, OrderValidationProblem.OrderLinesHasNoItems);
        }

s8.cs

        private T GetThrownException<T>(Action code) where T : Exception
        {
            try
            {
                code();
            }
            catch (T expectedException)
            {
                return expectedException;
            }
            catch (Exception e) {}
 
            Assert.Fail("Expected exception of type {0} was not thrown", typeof(T).FullName);
            return null;
        }

s9.cs

        private void CheckExceptionAndProblem(Func<Decimal> function,
            OrderValidationProblem expectedOrderValidationProblem)
        {
            var expectedException = GetThrownException<OrderValidationException>(() => function());
            Assert.AreEqual(expectedOrderValidationProblem, expectedException.Problem);
        }