Mock HttpContext.Current nel metodo Init Test

Sto cercando di aggiungere test unitari a un'applicazione ASP.NET MVC che ho creato. Nei test unitari utilizzo il seguente codice:

[TestMethod]
public void IndexAction_Should_Return_View() {
    var controller = new MembershipController();
    controller.SetFakeControllerContext("TestUser");

    ...
}

Con i seguenti helper per deridere il contesto del controller:

public static class FakeControllerContext {
    public static HttpContextBase FakeHttpContext(string username) {
        var context = new Mock<HttpContextBase>();

        context.SetupGet(ctx => ctx.Request.IsAuthenticated).Returns(!string.IsNullOrEmpty(username));

        if (!string.IsNullOrEmpty(username))
            context.SetupGet(ctx => ctx.User.Identity).Returns(FakeIdentity.CreateIdentity(username));

        return context.Object;
    }

    public static void SetFakeControllerContext(this Controller controller, string username = null) {
        var httpContext = FakeHttpContext(username);
        var context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
        controller.ControllerContext = context;
    }
}

Questa classe di test eredita da una classe di base che ha i seguenti:

[TestInitialize]
public void Init() {
    ...
}

All'interno di questo metodo chiama una libreria (di cui non ho alcun controllo) che tenta di eseguire il codice seguente:

HttpContext.Current.User.Identity.IsAuthenticated

Ora puoi probabilmente vedere il problema. Ho impostato il falso HttpContext sul controller ma non in questo metodo Init di base. Il test di unità / derisione è molto nuovo per me, quindi voglio assicurarmi di farlo bene. Qual è il modo corretto per me di deridere HttpContext in modo che sia condiviso attraverso il mio controller e tutte le librerie che sono chiamate nel mio metodo Init.

HttpContext.Currentrestituisce un'istanza di System.Web.HttpContext, che non si estende System.Web.HttpContextBase. HttpContextBaseè stato aggiunto in seguito per HttpContextessere difficile da deridere. Le due classi sono sostanzialmente indipendenti ( HttpContextWrapperviene utilizzato come adattatore tra di loro).

Fortunatamente, di per HttpContextsé è contraffatto quanto basta per sostituire IPrincipal(Utente) e IIdentity.

Il codice seguente viene eseguito come previsto, anche in un'applicazione console:

HttpContext.Current = new HttpContext(
    new HttpRequest("", "http://tempuri.org", ""),
    new HttpResponse(new StringWriter())
    );

// User is logged in
HttpContext.Current.User = new GenericPrincipal(
    new GenericIdentity("username"),
    new string[0]
    );

// User is logged out
HttpContext.Current.User = new GenericPrincipal(
    new GenericIdentity(String.Empty),
    new string[0]
    );

Sotto Test Init farà anche il lavoro.

[TestInitialize]
public void TestInit()
{
  HttpContext.Current = new HttpContext(new HttpRequest(null, "http://tempuri.org", null), new HttpResponse(null));
  YourControllerToBeTestedController = GetYourToBeTestedController();
}

So che questo è un argomento più vecchio, tuttavia deridere un'applicazione MVC per i test unitari è qualcosa che facciamo regolarmente.

Volevo solo aggiungere le mie esperienze deridendo un'applicazione MVC 3 usando Moq 4 dopo l'aggiornamento a Visual Studio 2013. Nessuno dei test unit funzionava in modalità debug e HttpContext mostrava "impossibile valutare l'espressione" quando cercava di sbirciare le variabili .

Risulta che Visual Studio 2013 ha problemi con la valutazione di alcuni oggetti. Per far funzionare di nuovo il debug delle applicazioni Web derise, ho dovuto controllare la "Modalità di compatibilità gestita" in Strumenti => Opzioni => Debug => Impostazioni generali.

In genere faccio qualcosa del genere:

public static class FakeHttpContext
{
    public static void SetFakeContext(this Controller controller)
    {

        var httpContext = MakeFakeContext();
        ControllerContext context =
        new ControllerContext(
        new RequestContext(httpContext,
        new RouteData()), controller);
        controller.ControllerContext = context;
    }


    private static HttpContextBase MakeFakeContext()
    {
        var context = new Mock<HttpContextBase>();
        var request = new Mock<HttpRequestBase>();
        var response = new Mock<HttpResponseBase>();
        var session = new Mock<HttpSessionStateBase>();
        var server = new Mock<HttpServerUtilityBase>();
        var user = new Mock<IPrincipal>();
        var identity = new Mock<IIdentity>();

        context.Setup(c=> c.Request).Returns(request.Object);
        context.Setup(c=> c.Response).Returns(response.Object);
        context.Setup(c=> c.Session).Returns(session.Object);
        context.Setup(c=> c.Server).Returns(server.Object);
        context.Setup(c=> c.User).Returns(user.Object);
        user.Setup(c=> c.Identity).Returns(identity.Object);
        identity.Setup(i => i.IsAuthenticated).Returns(true);
        identity.Setup(i => i.Name).Returns("admin");

        return context.Object;
    }


}

E iniziando il contesto in questo modo

FakeHttpContext.SetFakeContext(moController);

E chiamando direttamente il metodo nel controller

long lReportStatusID = -1;
var result = moController.CancelReport(lReportStatusID);

Se la tua applicazione di terze parti reindirizza internamente, quindi è meglio deridere HttpContext nel modo seguente:

HttpWorkerRequest initWorkerRequest = new SimpleWorkerRequest("","","","",new StringWriter(CultureInfo.InvariantCulture));
System.Web.HttpContext.Current = new HttpContext(initWorkerRequest);
System.Web.HttpContext.Current.Request.Browser = new HttpBrowserCapabilities();
System.Web.HttpContext.Current.Request.Browser.Capabilities = new Dictionary<string, string> { { "requiresPostRedirectionHandling", "false" } };