TDD and Protected Methods

Question

I am trying to learn TDD by creating a copy of an existing MVC app I have but I am creating a copy of it from scratch using TDD.

In my existing app I have an Application_AuthenticateRequest method as shown below.

This is protected. Am I right in thinking that these methods should not be tested - ie you should only test public methods and not private and protected ones. If this is true then would I just code away my protected method below without writing any tests for it?

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        WebApiConfig.Register(GlobalConfiguration.Configuration);
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
        StaticDataSeeder.Seed();
    }

    protected void Application_AuthenticateRequest(Object sender, EventArgs e)
    {
        HttpCookie authCookie = Context.Request.Cookies[FormsAuthentication.FormsCookieName];

        if (authCookie == null) return;

        var authTicket = FormsAuthentication.Decrypt(authCookie.Value);

        if (authTicket == null) return;

        var userData = new UserDataModel(authTicket.UserData);

        var userPrincipal = new PaxiumPrincipal(new GenericIdentity(authTicket.Name), null)
        {
            Email = userData.Email,
            Menu = userData.Menu,
            RememberMe = userData.RememberMe
        };

        Context.User = userPrincipal;
    }
}

Answer 1

Just having tests doesn't make it TDD. If you already assume private method that does something, Development wasn't Driven by Tests, was it?

Try to go blind and write tests first, you might end up not needing the private method at all or even having it as a public method in another class.

Answer 2

Yes you are correct with your test case you can only test the methods which you can invoke. So generally public methods are testable. Again, if you have a private method in your component that means it must be invoked by at least one public method in that component. So while you are testing you public method , you are also testing the private method's functionality in the same test. Private methods you can consider as few lines of the public method keeping out side that public method to make the code more readable and for re-usability purpose.

Answer 3

Protected methods create a contract between the class you're creating and it's future children. If you didn't want to create this contract, you'd be defining the methods as private, not protected. As such, I'd argue that you should be testing that the behaviour of those methods matches the expectations that any derived classes would expect.

Consider an two classes:

public abstract class BaseMathsClass {
    protected int Mult(int a, int b) {
        return a * b;
    }
}

public class ConcreteMathClass : BaseMathsClass {
    public int Square(int x) {
        return Mult(x, x);
    }
}

If you're happy testing the functionality of the Mult method in your tests for ConcreteMathClass, then you don't need to write tests for the base class. However, if you do write tests for the base class, this cements the contract at the time that the base class is written and means that any derived classes know what they're signing up for. Which side of the fence you come down on, depends on your opinion. This question has some other opinions.

You also say that you believe you don't need to test private methods. This is true in that you don't need to write specific tests to call private methods directly, however you should be testing the functionality of any private methods implicitly through your tests against the public methods of a class. When writing your tests, you shouldn't really care if your class has either of the following implementations:

Implementation 1

class MyClass {
    public int GetSquare(int someValue) {
        return someValue * someValue;
    }
}

Implementation 2

class MyClass {
    public int GetSquare(int someValue) {
        return Mult(someValue, someValue);
    }

    private int Mult(int a, int b) {
        return a * b;
    }
}

With implementation 2, you don't need to write a test that specifically calls Mult, the tests for GetSquare sufficiently exercise this code. This doesn't mean you would just code up another private method Add, because at the moment there isn't a need for it on your public interface.

You may also be interested in the answers to this question.