Allow Access to Protected Class Members

[damepatr]

Hi folks! 👋

Summary

As far as I know, Moq doesn't provide direct access to protected class members. You can call ProtectedExtension.Protected<T>(Mock<T> mock) to setup the mock's protected members, but you can't directly get/set protected properties/fields, and you can't directly call protected methods. This can make it difficult to mock a base class and test the base class's functionality.

Example

Suppose that you have the following:

public abstract class BaseClass {
    protected string _commonField;

    protected BaseClass() {
        _commonField = GetStringWithId("SomeId");
    }

    public string GetStringWithId(string id) {
        // Returns string with given ID.
    }
}

public class FirstImplementation : BaseClass  {
    public FirstImplementation() : base() { }

    public void SomeMethod() {
        // Uses _commonField.
    }
}

public class SecondImplementation : BaseClass {
    public SecondImplementation() : base() { }

    public void AnotherMethod() {
        // Uses _commonField
    }
}

Since _commonField is used by implementors, I would argue that you should create a unit test for the _commonField property. Ideally, you would do this by using the partial mock feature with BaseClass. This unit test would validate that _commonField is getting set correctly in the constructor; that way you can validate that the correct value is getting provided to FirstImplementation and SecondImplementation.

The concern is that Moq doesn't provide direct access to the _commonField field, so you can't verify that it is getting set correctly. Instead, you either have to (a) create your own mock or (b) use reflection.

[kzu]

This is not a Moq issue, but a design issue. A protected field (non-readonly even!) can be overwritten by anyone at any point. Not a great design to preserve the invariants of the class.

If you need to expose internal state just for verification in tests, I'd suggest creating internal members that expose whatever you need and perform regular state assertions on the resulting (mock) object itself. You can make those members visible with InternalsVisibleTo easily.

That said, having your tests so deeply tied to internal object state is a recipe for brittle tests that need to be constantly changed whenever implementations (inevitably) evolve.

[damepatr]

Ok, I think that I see now. You can use reflection, internal protected, or a manual mock to expose the protected _weightClass property.

[damepatr]

My initial thought process was that we could add a way to get the protected _weightClass property. An advantage of manual mocking is that you can add public members which expose protected members. The issue is that Moq.Mock<T>.Object returns type T, and that means that we can't add public members.

[damepatr]

You could potentially return an object that inherits from T but provides additional members for accessing protected members. This could be done with the TypeBuilder class, but it seems complicated. It would probably be best to keep things simple.

[kzu]

You just make a Mock of the derived type that exposes the additional protected members as public members and just passes whatever ctor args to the base ctor. Just like you would with a manual mock too, btw.

[damepatr]

You just make a Mock of the derived type that exposes the additional protected members as public members and just passes whatever ctor args to the base ctor. Just like you would with a manual mock too, btw.

Yeah, this makes sense. I think that this is preferable to exposing protected members through the TypeBuilder class.