Mocking Client Object Model's ClientContext with Moles

Question

I've been tasked with writing a small C# tool to fetch and fiddle with some Sharepoint 2010 items using the Sharepoint Client Object Model (COM). The code will typically have something like this in the beginning:

public void foo(ClientContext clientContext ) {
    Web web = clientContext.Web;
    clientContext.Load(web);
    clientContext.ExecuteQuery();
    ...
}

To unit test this, I was planning to use Microsoft's Mole. So I try to make a test with a mock ClientContext like the following. The problem here is that I'm unable to make a mock implementation of the Load method.

MClientContext ctx = new MClientContext {
    WebGet       = () => new MWeb {},
    ExecuteQuery = () => {}
    //,Load = () => {} .... problem
};

VS tells me there's no definition for Load in Microsoft.SharePoint.Client.Moles.MClientContext.

The ClientContext's Load method is inherited from ClientRuntimeContext (I checked this with JustDecompile).

public void Load<T>(T clientObject, params Expression<Func<T, object>>[] retrievals)
where T : ClientObject
{
    if (clientObject == null)
    {
        throw new ArgumentNullException("clientObject");
    }
    DataRetrieval.Load<T>(clientObject, retrievals);
}

So the question is, how does one create a mock ClientContext with Mole, complete with the inherited Load method, for unit testing? Is there some other trick to unit testing Client Object Model code?

Anything from example snippets to links would be greatly appreciated.

note: I'm very new to Sharepoint (and C#.... and, tbh, mocking). note2: I'm not able to get the paid TypeMock version, which I'm told could possibly accomplish this.

## Update: Solved! Essential clues provided by Nathan below ##

MClientContext ctx = new MClientContext {
    WebGet       = () => new MWeb {},
    ExecuteQuery = () => {}
    /* .... */
};

var ctxBase = new MClientRuntimeContext(ctx);
ctxBase.LoadTExpressionOfFuncOfTObjectArray<ListItemCollection>((a,b) => {}); 

This means my Moled ClientContext can now do:

ctx.Load(someInstanceOfListItemCollection);
ctx.ExecuteQuery();

Answer 1

The reason Visual Studio is telling you that "Load does not exist", is because you are not matching the method signature.

Your sample code shows that you are using Load = () => {} to attempt to define the behavior, however, the only signature (I'm looking at the SharePoint 2013 client object model here - "Microsoft.SharePoint.Client.dll, v15.0.0.0") for Load is

public void Load<T>(T clientObject, params Expression<Func<T, object>>[] retrievals)
                   where T : ClientObject;

You have told the compiler to look for a no-argument version of Load which doesn't exist.

So instead, you need to match the method signature. Having never used Moles myself, I can't guarantee this is correct, but I suspect you simply need to do something like:

MClientContext ctx = new MClientContext {
    WebGet       = () => new MWeb {},
    ExecuteQuery = () => {},
    Load = (clientObject, retrievals) => {}
};

I also note that it appears you are using "Moles" rather than "Stubs". Another approach would be to wrap all your calls to the ClientContext behind your own interface, which you could then provide stubbed implementations to for your test, and "real" implementations for your production code. To go that route, you will probably want to look at some sort of Dependency Injection framework.

Update

It also appears that to access a method from a base type in a Mole, you must Mole both the base type and the child type. See the Moles Manual page 20, in the section "Base Types", where it states:

The mole properties of base members can be accessed by creating a mole for the base type and passing the child instance as a parameter to the constructor of the base mole class.

Answer 2

Here is how you can use the Microsoft Fakes Framework for mocking the SharePoint ClientContext class.

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.QualityTools.Testing.Fakes;
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.Fakes;

namespace MyNamespace
{
    [TestClass]
    public class MyTestClass
    {
        [TestMethod]
        public void MyTestMethod()
        {
            using (ShimsContext.Create())
            {
                // Create shims for the ClientContext class and its base class
                var ctx = new ShimClientContext();
                var ctxBase = new ShimClientRuntimeContext(ctx);

                var site = new ShimSite();
                var web = new ShimWeb();

                ctx.SiteGet = () => { return site; };
                ctx.WebGet = () => { return web; };
                ctx.ExecuteQuery = () => { };

                // Add implementation for ctx.Load<Site>(...)
                ctxBase.LoadOf1M0ExpressionOfFuncOfM0ObjectArray<Site>((a, b) => { });
                ctxBase.LoadQueryOf1ClientObjectCollectionOfM0<Site>(delegate { return null; });
                ctxBase.LoadQueryOf1IQueryableOfM0<Site>(delegate { return null; });

                // Add implementation for ctx.Load<Web>(...)
                ctxBase.LoadOf1M0ExpressionOfFuncOfM0ObjectArray<Web>((a, b) => { });
                ctxBase.LoadQueryOf1ClientObjectCollectionOfM0<Web>(delegate { return null; });
                ctxBase.LoadQueryOf1IQueryableOfM0<Web>(delegate { return null; });

                // Add implementation for ctx.Load<User>(...)
                ctxBase.LoadOf1M0ExpressionOfFuncOfM0ObjectArray<User>((a, b) => { });
                ctxBase.LoadQueryOf1ClientObjectCollectionOfM0<User>(delegate { return null; });
                ctxBase.LoadQueryOf1IQueryableOfM0<User>(delegate { return null; });

                var user = new ShimUser();
                var userPrincipal = new ShimPrincipal(user);
                userPrincipal.LoginNameGet = () => { return "i:0#.f|membership|user@domain.onmicrosoft.com"; };
                web.CurrentUserGet = () => { return user; };
                web.TitleGet = () => { return "Title"; };

                // Test with the ClientContext ctx
                ctx.Load(ctx.Web, web => web.Title);
                ctx.Load(ctx.Web.CurrentUser, user => user.LoginName);
                ctx.ExecuteQuery();

                ...
            }
        }
    }
}