Mocks und Stubs im Einsatz (TDD Part 2)

/// <summary>
/// Connects to the local business database.
/// </summary>
internal static class Service
{
   public static IEnumerable<Invoice> GetInvoices()
   {
      throw new NotImplementedException();
   }
}

public class Invoice
 {
    // Code ohne Bezug zu diesem Absatz ausgeblendet.

    public void SendToCollection()
    {
       throw new NotImplementedException();
    }
 }

internal class WcfHttpCollectionAgencyService : ICollectionAgencyService
{   
   public Invoice GetInvoice(string invoiceNumber)
   {
      throw new NotImplementedException();
   }

   public bool SendInvoice(Invoice invoice)
   {
      throw new NotImplementedException();
   }
}

var overDue = new OverDueSpecification();
var noticeSent = new NoticeSentSpecification();
var inCollection = new InCollectionSpecification();

ISpecification<Invoice> sendToCollection =
   overDue.And(noticeSent).And(inCollection.Not());

IEnumerable<Invoice> invoiceCollection = Service.GetInvoices();

foreach(Invoice currentInvoice in invoiceCollection)
{
   if(sendToCollection.IsSatisfiedBy(currentInvoice))
   {
      currentInvoice.SendToCollection();
   }
}

using System;
using System.Collections.Generic;

namespace SpecificationPatternWikipedia.Tests.Stubs
{
   internal static class InvoiceStubsAndFakes
   {
      static InvoiceStubsAndFakes()
      {
         TempInvoiceRepository = new List<Invoice>();
         /* Prepare the TempInvoiceRepo.
         * Invoice "65432" should already be there. */
         foreach(var invoice in BadInvoicesAtCollectionAgency)
         {
            AddToTempInvoiceRepository(invoice);
         }
      }

      /// <summary>
      /// Gets a list of 3 different fake invoices.
      /// ACME corp is never over due and has 0 notices sent.
      /// Invoice number is "12345". 
      /// Bad Guys Inc is over due and they got 3 notices sent.
      /// Invoive number is "98765". 
      /// Evil guys is over due, has 3 notices sent and the collection agency
      /// has a copy of their invoice.
      /// Invoive number is "65432". 
      /// </summary>
      internal static List<Invoice> AllInvoices
      {
         get
         {
            return new List<Invoice>
                      {
                         new Invoice
                            {
                               Customer = new Customer
                                             {
                                                Name = "ACME corp.",
                                                AmountOfNoticesSent = 0
                                             },
                               DueDate = DateTime.Now,
                               InvoiceNumber = "12345",
                               AtCollectionAgency = false
                            },
                         new Invoice
                            {
                               Customer = new Customer
                                             {
                                                Name = "Bad Guys Inc",
                                                AmountOfNoticesSent = 3
                                             },
                               DueDate = new DateTime(2010, 6, 23),
                               InvoiceNumber = "98765",
                               // Not yet at the collection agency.
                               AtCollectionAgency = false
                            },
                         new Invoice
                            {
                               Customer = new Customer
                                             {
                                                Name = "Evil Guys",
                                                AmountOfNoticesSent = 3
                                             },
                               DueDate = new DateTime(2010, 6, 23),
                               InvoiceNumber = "65432",
                               AtCollectionAgency = true
                            }
                      };
         }
      }

      internal static List<Invoice> GoodInvoices
      {
         get
         {
            return new List<Invoice>
                      {
                         AllInvoices.Find(invoice =>
                                          invoice.InvoiceNumber == "12345")
                      };
         }
      }

      internal static List<Invoice> BadInvoicesNotAtCollectionAgency
      {
         get
         {
            return new List<Invoice>
                      {
                         AllInvoices.Find(invoice =>
                                          invoice.InvoiceNumber == "98765")
                      };
         }
      }

      internal static List<Invoice> BadInvoicesAtCollectionAgency
      {
         get
         {
            return new List<Invoice>
                      {
                         AllInvoices.Find(invoice =>
                                          invoice.InvoiceNumber == "65432")
                      };
         }
      }

      internal static List<Invoice> TempInvoiceRepository { get; private set; }

      internal static void AddToTempInvoiceRepository(Invoice invoice)
      {
         if (!TempInvoiceRepository.Contains(invoice))
            TempInvoiceRepository.Add(invoice);
      }
   }
}

internal class InCollectionSpecification : ISpecification<Invoice>
{
   #region ISpecification<Invoice> Members

   /// <summary>
   /// Is satisfied when an invoice has already been sent to the collection agency.
   /// </summary>
   public bool IsSatisfiedBy(Invoice entity)
   {
      /* Question: Soll der Customer ein Property erhalten,
       * das angibt ob die collection agency benachrichtigt wurde,
       * oder soll ich ein CollectionAgency-Objekt machen,
       * oder eine Serviceverbindung mit einem Request?
       * Ich entscheide mich für einen Service-Request.*/

      ICollectionAgencyService collectionAgencyService = new WcfHttpCollectionAgencyService();
      Invoice tempInvoice = collectionAgencyService.GetInvoice(entity.InvoiceNumber);
      return tempInvoice != null;
   }

   #endregion ISpecification<Invoice> Members
}

internal class InCollectionSpecification : ISpecification<Invoice>
{
   private readonly ICollectionAgencyService collectionAgencyService;

   internal InCollectionSpecification(
      ICollectionAgencyService collectionAgencyService)
   {
      this.collectionAgencyService = collectionAgencyService;
   }

   #region ISpecification<Invoice> Members

   /// <summary>
   /// Is satisfied when an invoice has already been sent to
   ///  the collection agency.
   /// </summary>
   public bool IsSatisfiedBy(Invoice entity)
   {
      // Nicht sicher:
      //bool result = entity.AtCollectionAgency;
      //return result;
      
      // Sicher:
      var tempInvoice =
         collectionAgencyService.GetInvoice(entity.InvoiceNumber);
      return tempInvoice != null;
   }

   #endregion ISpecification<Invoice> Members
}

[TestMethod]
public void PatternTest()
{
   // Arrange
   var collectionAgencyService = new Mock<ICollectionAgencyService>();
   SetupGetInvoiceMock(collectionAgencyService);
   SetupSendToCollectionMock(collectionAgencyService);
   Mock<IRepository> repository = MockRepositoryGetAllInvoices();
   
   // Pattern Setup
   var overDue = new OverDueSpecification();
   var noticeSent = new NoticeSentSpecification();
   var inCollection =
      new InCollectionSpecification(collectionAgencyService.Object);
   ISpecification<Invoice> sendToCollection =
      overDue.And(noticeSent).And(inCollection.Not());
   IEnumerable<Invoice> invoiceCollection =
      Service.GetInvoices(repository.Object);
   
   // Act
   foreach (Invoice currentInvoice in invoiceCollection)
   {
      if (sendToCollection.IsSatisfiedBy(currentInvoice))
      {
         currentInvoice.SendToCollection(collectionAgencyService.Object);
         Console.WriteLine("Invoice number {0} has been sent to the "
                           + "collection agency.",
                           currentInvoice.InvoiceNumber);
      }
   }
   
   // Assert
   Assert.AreEqual(2, InvoiceStubsAndFakes.TempInvoiceRepository.Count);
   Assert.IsNotNull(InvoiceStubsAndFakes.TempInvoiceRepository
                       .Find(number => number.InvoiceNumber == "98765"));
   Assert.IsNotNull(InvoiceStubsAndFakes.TempInvoiceRepository
                       .Find(number => number.InvoiceNumber == "65432"));
}

private static void SetupGetInvoiceMock(
   Mock<ICollectionAgencyService> collectionAgencyService)
{
   collectionAgencyService.Setup(agencyService =>
                                 agencyService
                                    .GetInvoice(It.IsAny<String>()))
      .Returns((string invoiceNumber) =>
               InvoiceStubsAndFakes.TempInvoiceRepository
                  .Find(invoice =>
                        invoice.InvoiceNumber ==
                        invoiceNumber));
}

private static void SetupSendToCollectionMock(
   Mock<ICollectionAgencyService> collectionAgencyService)
{
   collectionAgencyService
      .Setup(agencyService => agencyService
                                 .SendInvoice(It.IsAny<Invoice>()))
      .Returns((Invoice invoice) =>
                  {
                     InvoiceStubsAndFakes
                        .AddToTempInvoiceRepository(invoice);
                     return InvoiceStubsAndFakes.TempInvoiceRepository
                               .Find(tempInvoice =>
                                     tempInvoice.InvoiceNumber ==
                                     invoice.InvoiceNumber)
                            != null;
                  });
}

private static Mock<IRepository> MockRepositoryGetAllInvoices()
{
   var repository = new Mock<IRepository>();
   repository.Setup(repo => repo.GetAllInvoices())
      .Returns(() => InvoiceStubsAndFakes.AllInvoices);
   return repository;
}

/// <summary>
/// Connects to the business database.
/// </summary>
internal static class Service
{
   /* Note: Schlechte Architektur. Mit deser Signatur müsste diese Methode
    * die Serviceverbindung selbsttätig und fest gekoppelt vornehmen. */
   [Obsolete("Architekturfehler", true)]
   public static IEnumerable<Invoice> GetInvoices()
   {
      throw new NotImplementedException();
   }

   public static IEnumerable<Invoice> GetInvoices(IRepository repository)
   {
      return repository.GetAllInvoices();
   }
}

//======================================================================

public interface IRepository
{
   IEnumerable<Invoice> GetAllInvoices();
   // Add more...
}

//======================================================================

public class Repository : IRepository
{
   public IEnumerable<Invoice> GetAllInvoices()
   {
      throw new NotImplementedException();
   }
}

//======================================================================

public class Invoice
{
   public string InvoiceNumber { get; set; }

   public Customer @Customer { get; set; }

   public DateTime DueDate { get; set; }

   public bool AtCollectionAgency { get; set; }

   /* Note: Schlechte Architektur. Mit deser Signatur müsste diese Methode
    * die Serviceverbindung selbsttätig und fest gekoppelt vornehmen. */
   [Obsolete("Architekturfehler", true)]
   public void SendToCollection()
   {
      throw new NotImplementedException();
   }

   /// <summary>
   /// Sendet die Rechnung an den CollectionAgencyService.
   /// </summary>
   /// <param name="service">Eine konkrete Service-Instanz, die den
   /// ICollectionAgencyService-Contract erfüllt.</param>
   /// <returns><c>true</c> wenn die Rechnung erfolgreich übermittelt wurde,
   /// anderenfalls <c>false</c>.</returns>
   public bool SendToCollection(ICollectionAgencyService service)
   {
      bool successfullySent = service.SendInvoice(this);
      if(successfullySent)
         AtCollectionAgency = true;
      return successfullySent;
   }
}