Mocking the whole PnPContext?

[plamber]

Category

• Feature request

Describe the feature

I followed the issue #948 since we have to write a couple of Unit Tests for our environment. We can already use the IPnPContext interface to mock a couple of items but I noticed that many interfaces or properties are not "Mockable".

I am just going to list a couple of examples.

Methods or properties not present in PnPContext

• context.ExecuteAsync
• context.Uri
• GetSiteCollectionManager

Describe the solution you'd like

The interface should include all methods and properties available in PnPContext. This simplify the Mocking process when writing Unit Tests.

[jansenbe]

@plamber : I've just pushed a change that will bring all the public properties and methods to the IPnPContext interface. The GetSiteCollectionManager one is not there yet, this method is added as extension method for the folks that use the admin library, so can't declare that method on the IPnPContext interface.

I've not played much with mocking frameworks, if you've creative ideas to fix this then please let me know (or submit a PR).

We don't have documentation on how to use mocking frameworks to test PnP Core SDK...would you willing to help with that? Or share some samples (the thing I tried in #948 is too basic).

Thx!

[plamber]

Hi @jansenbe,
I appreciate your help.

We started with the Unit Tests for the PnP Framework recently. I will collect some lessons learned from our project and share them with you guys. I think in a couple of weeks, I can share more.

Regarding the mocking of extensions methods, we are using Option 1 of this article for our own extensions:
http://adventuresdotnet.blogspot.com/2011/03/mocking-static-methods-for-unit-testing.html
What I noticed with this method is that if you perform many parallel tests, the tests may fail.

I haven't tested option 2 (delegates) presented in the article. Maybe this could be a viable solution for the PnP Framework.

Let me know what you think about it.

Cheers

[plamber]

Hi @jansenbe,
do you think it might be possible to extend the IPnPContext with the IDisposable interface?

By doing so, we can write code like this

using var context = await _spoRepository.GetContextAsync(root.WebUrl);

when using the interface. I assume there is no negative impact since PnPContext is implementing IDisposable

Cheers,
patrick

[jansenbe]

@plamber : just done

[jansenbe]

@plamber : are you good with closing this one?

[plamber]

Hi @jansenbe,
we can close it.

I wanted to show you how I will use the IPnPContext with the admin extensions. I created a dedicated extension that looks like this.

public static class PnPContextExtensions
{
    public static ISharePointAdmin GetSharePointAdmin(this IPnPContext context)
    {
        return PnP.Core.Services.PnPContextExtensions.GetSharePointAdmin(context as PnPContext);
    }

    public static ISiteCollectionManager GetSiteCollectionManager(this IPnPContext context)
    {
        return PnP.Core.Services.PnPContextExtensions.GetSiteCollectionManager(context as PnPContext);
    }
}

This allows me to work with the IPnPContext in the whole project.

Cheers

[jansenbe]

@plamber : would you've time to write a short documentation page on using Moq with PnP Core SDK?

[plamber]

Hi @jansenbe,
I will do it. I still want to test a couple of scenarios first.

Cheers

[plamber]

Hi @jansenbe,
I need help in mocking the extension methods. I want to ask you if you could consider the design "Option 1 – Wrapper Class" from http://adventuresdotnet.blogspot.com/2011/03/mocking-static-methods-for-unit-testing.html.

The idea is during unit test to call the static method "PnPContextExtensions.Implementation" and put there a Mock of the implementation. If we want to use free libraries like Moq, we need to add a couple of helper classes and interfaces.

First, we need an interface that defines the methods of the extension methods:

public interface IPnPContextExtensions
{
    public ISharePointAdmin GetSharePointAdmin(this PnPContext context);
    public ISiteCollectionManager GetSiteCollectionManager(this PnPContext context);
    public ITeamManager GetTeamManager(this PnPContext context);
    public ITenantAppManager GetTenantAppManager(this PnPContext context);
    public ISiteCollectionAppManager GetSiteCollectionAppManager(this PnPContext context);
    public IMicrosoft365Admin GetMicrosoft365Admin(this PnPContext context);
}

Here I would even improve further and not reference the PnPContext but the IPnPContext instead. Something like this:

public interface IPnPContextExtensions
{
    public ISharePointAdmin GetSharePointAdmin(this IPnPContext context);
    public ISiteCollectionManager GetSiteCollectionManager(this IPnPContext context);
    public ITeamManager GetTeamManager(this IPnPContext context);
    public ITenantAppManager GetTenantAppManager(this IPnPContext context);
    public ISiteCollectionAppManager GetSiteCollectionAppManager(this IPnPContext context);
    public IMicrosoft365Admin GetMicrosoft365Admin(this IPnPContext context);
}

Then, we need to transfer the logic of the existing PnPContextExtension to a nonstatic class that implements the interface defined above. The constructor of that class can be private to ensure that nobody references it outside the project.

public class PnPInternalContextExtension : IPnPContextExtensions
{
    private PnPInternalContextExtension()
    {

    }

    public IMicrosoft365Admin GetMicrosoft365Admin(IPnPContext context)
    {
        // move the implementation of the extension method here
    }

    public ISharePointAdmin GetSharePointAdmin(IPnPContext context)
    {
        // move the implementation of the extension method here
    }

    public ISiteCollectionAppManager GetSiteCollectionAppManager(IPnPContext context)
    {
        // move the implementation of the extension method here
    }

    public ISiteCollectionManager GetSiteCollectionManager(IPnPContext context)
    {
        // move the implementation of the extension method here
    }

    public ITeamManager GetTeamManager(IPnPContext context)
    {
        // move the implementation of the extension method here
    }

    public ITenantAppManager GetTenantAppManager(IPnPContext context)
    {
        // move the implementation of the extension method here
    }
}

Last but not least, we implement the "new" Extension method that will become the wrapper of the default implementation.

public static class PnPContextExtensions
{
    private static readonly IPnPContextExtensions defaultImplementation = new PnPInternalContextExtension ();
    public static IPnPContextExtensions Implementation { private get; set; } = defaultImplementation;

    public static void RevertToDefaultImplementation()
    {
        Implementation = defaultImplementation;
    }

    public static IMicrosoft365Admin GetMicrosoft365Admin(this IPnPContext context)
    {
        return Implementation.GetMicrosoft365Admin(context);
    }

    public static ISharePointAdmin GetSharePointAdmin(this IPnPContext context)
    {
        return Implementation.GetSharePointAdmin(context);
    }

    public static ISiteCollectionAppManager GetSiteCollectionAppManager(this IPnPContext context)
    {
        return Implementation.GetSiteCollectionAppManager(context);
    }

    public static ISiteCollectionManager GetSiteCollectionManager(this IPnPContext context)
    {
        return Implementation.GetSiteCollectionManager(context);
    }

    public static ITeamManager GetTeamManager(this IPnPContext context)
    {
        return Implementation.GetTeamManager(context);
    }

    public static ITenantAppManager GetTenantAppManager(this IPnPContext context)
    {
        return Implementation.GetTenantAppManager(context);
    }
}

Once this is done, we can use, for example, Moq and replace the implementation of the extension method before starting the unit test and tear it down after the unit test has been completed.

Mock<IPnPContextExtensions> mockObject = new Mock<IPnPContextExtensions>();
PnPContextExtensions.Implementation = mockObject.Object;
// test
PnPContextExtensions.Implementation = PnPContextExtensions.defaultImplementation;

Let me know what you think about this. The approach works well as long as the unit test framework ensures that tests are executed in sequence. An alternative I found would be to use paid testing Frameworks.

Cheers,
Patrick