Testing und mocking private/protected-Methoden. Viele Beiträge aber noch nicht machen, ein Beispiel der Arbeit

Die Schritte die du beschreibst set Moq bis zu test-internen Klassen und Mitgliedern, so haben Sie wirklich nichts zu tun mit der Prüfung einer geschützten oder privaten Methode

Testen von privaten Methoden ist ein bisschen ein Geruch, sollte wirklich test nur die öffentliche API. Wenn Sie glauben, dass die Methode ist wirklich wichtig und muss isoliert getestet werden es vielleicht verdient zu werden in seiner eigenen Klasse, wo es kann dann getestet werden, auf Ihre eigenen?

Wenn Ihr Herz ist auf die Prüfung der protected-Methode, die oben, können Sie Rollen Sie Ihre eigenen Mock in Ihrer test-Montage:

public class CustomerServiceMock : CustomerService {
    public void DoSomethingTester() {
         //Set up state or whatever you need
         DoSomething();
    }

}

[TestMethod]
public void DoSomething_WhenCalled_DoesSomething() {
    CustomerServiceMock serviceMock = new CustomerServiceMock(...);
    serviceMock.DoSomethingTester();
 }

Wenn es privat könnte Sie wahrscheinlich etwas heftig, mit Reflexion aber, die route ist der Weg zum testen der Hölle.

Update

Während Sie gegeben haben Beispiel-code in deiner Frage sehe ich nicht wirklich, wie Sie wollen, um zu "testen", die geschützte Methode, so werde ich kommen mit etwas gekünstelt...

Lets sagen, dass Ihre Kunden-service sieht wie folgt aus:-

 public CustomerService : ICustomerService {

      private readonly ICustomerRepository _repository;

      public CustomerService(ICustomerRepository repository) {
           _repository = repository;
      } 

      public void MakeCustomerPreferred(Customer preferred) {
           MakePreferred(customer);
           _repository.Save(customer);
      }

      protected virtual void MakePreferred(Customer customer) {
          //Or more than likely some grungy logic
          customer.IsPreferred = true;
      }
 }

Wenn Sie testen wollten, die protected-Methode können Sie nur so etwas wie:-

[TestClass]
public class CustomerServiceTests {

     CustomerServiceTester customerService;
     Mock<ICustomerRepository> customerRepositoryMock;

     [TestInitialize]
     public void Setup() {
          customerRepoMock = new Mock<ICustomerRepository>();
          customerService = new CustomerServiceTester(customerRepoMock.Object);
     }


     public class CustomerServiceTester : CustomerService {    
          public void MakePreferredTest(Customer customer) {
              MakePreferred(customer);
          }

          //You could also add in test specific instrumentation
          //by overriding MakePreferred here like so...

          protected override void MakePreferred(Customer customer) {
              CustomerArgument = customer;
              WasCalled = true;
              base.MakePreferred(customer);
          }

          public Customer CustomerArgument { get; set; }
          public bool WasCalled { get; set; }
     }

     [TestMethod]
     public void MakePreferred_WithValidCustomer_MakesCustomerPreferred() {
         Customer customer = new Customer();
         customerService.MakePreferredTest(customer);
         Assert.AreEqual(true, customer.IsPreferred);
     }

     //Rest of your tests
}

Den Namen dieses "Muster" ist das Testen von bestimmten Unterklasse (basierend auf xUnit test patterns-Terminologie) für weitere Informationen möchten Sie vielleicht hier zu sehen:-

http://xunitpatterns.com/Test-Specific%20Subclass.html

Basierend auf Ihre Kommentare und die Vorherige Frage, wie es scheint, haben Sie beauftragt, die Implementierung der unit-tests auf, dass einige legacy-code (oder aus der Entscheidung selbst). In dem Fall die Bibel aller Dinge legacy code ist das Buch von Michael Feathers. Es umfasst Techniken wie das vorliegende als auch für refactorings und Techniken zu befassen sich mit brechen "nicht testbar" Klassen und Methoden, die in etwas mehr überschaubar und ich kann es nur wärmstens empfehlen.

InformationsquelleAutor John Foster