¿Cómo probar unitariamente un método de Acción que devuelve JsonResult?

Sé que llego un poco tarde a esto, pero descubrí por qué la solución dinámica no funcionaba:

JsonResult devuelve un objeto anónimo y estos son, por defecto, internal, por lo que deben ser visibles para el proyecto tests.

Abra su ASP.NET MVC proyecto de aplicación y buscar AssemblyInfo.cs de la carpeta llamada Propiedades. Abra AssemblyInfo.cs y agregue la siguiente línea al final de este archivo.

[assembly: InternalsVisibleTo("MyProject.Tests")]

Citado de: http://weblogs.asp.net/gunnarpeipman/archive/2010/07/24/asp-net-mvc-using-dynamic-type-to-test-controller-actions-returning-jsonresult.aspx

Pensé que sería bueno tener este para el registro. Funciona como un encanto

Llego un poco tarde a la fiesta, pero he creado una pequeña envoltura que me permite usar las propiedades dynamic. A partir de esta respuesta tengo esto trabajando en ASP.NET Core 1.0 RC2, pero creo que si reemplaza resultObject.Value con resultObject.Data debería funcionar para versiones no core.

public class JsonResultDynamicWrapper : DynamicObject
{
    private readonly object _resultObject;

    public JsonResultDynamicWrapper([NotNull] JsonResult resultObject)
    {
        if (resultObject == null) throw new ArgumentNullException(nameof(resultObject));
        _resultObject = resultObject.Value;
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        if (string.IsNullOrEmpty(binder.Name))
        {
            result = null;
            return false;
        }

        PropertyInfo property = _resultObject.GetType().GetProperty(binder.Name);

        if (property == null)
        {
            result = null;
            return false;
        }

        result = property.GetValue(_resultObject, null);
        return true;
    }
}

Uso, asumiendo el siguiente controlador:

public class FooController : Controller
{
    public IActionResult Get()
    {
        return Json(new {Bar = "Bar", Baz = "Baz"});
    }
}

La prueba (xUnit):

// Arrange
var controller = new FoosController();

// Act
var result = await controller.Get();

// Assert
var resultObject = Assert.IsType<JsonResult>(result);
dynamic resultData = new JsonResultDynamicWrapper(resultObject);
Assert.Equal("Bar", resultData.Bar);
Assert.Equal("Baz", resultData.Baz);

Extiendo la solución de Matt Greer y se me ocurre esta pequeña extensión:

    public static JsonResult IsJson(this ActionResult result)
    {
        Assert.IsInstanceOf<JsonResult>(result);
        return (JsonResult) result;
    }

    public static JsonResult WithModel(this JsonResult result, object model)
    {
        var props = model.GetType().GetProperties();
        foreach (var prop in props)
        {
            var mv = model.GetReflectedProperty(prop.Name);
            var expected = result.Data.GetReflectedProperty(prop.Name);
            Assert.AreEqual(expected, mv);
        }
        return result;
    }

Y acabo de ejecutar el unittest como este: - Establecer el resultado de los datos esperados:

        var expected = new
        {
            Success = false,
            Message = "Name is required"
        };

- Afirmar el resultado:

        // Assert
        result.IsJson().WithModel(expected);

Aquí hay uno que uso, tal vez sea de utilidad para cualquiera. Prueba una acción que devuelve un objeto JSON para su uso en la funcionalidad del lado del cliente. Utiliza Moq y FluentAssertions.

[TestMethod]
public void GetActivationcode_Should_Return_JSON_With_Filled_Model()
{
    // Arrange...
    ActivatiecodeController activatiecodeController = this.ActivatiecodeControllerFactory();
    CodeModel model = new CodeModel { Activation = "XYZZY", Lifespan = 10000 };
    this.deviceActivatieModelBuilder.Setup(x => x.GenereerNieuweActivatiecode()).Returns(model);

    // Act...
    var result = activatiecodeController.GetActivationcode() as JsonResult;

    // Assert...
    ((CodeModel)result.Data).Activation.Should().Be("XYZZY");
    ((CodeModel)result.Data).Lifespan.Should().Be(10000);
}

Mi solución es escribir el método de extensión:

using System.Reflection;
using System.Web.Mvc;

namespace Tests.Extensions
{
    public static class JsonExtensions
    {
        public static object GetPropertyValue(this JsonResult json, string propertyName)
        {
            return json.Data.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public).GetValue(json.Data, null);
        }
    }
}

Si en la prueba sabes exactamente cuál debe ser el resultado de los datos Json, entonces puedes hacer algo como esto:

result.Data.ToString().Should().Be(new { param = value}.ToString());

P.D. Esto sería si hubiera usado FluentAssertions.Mvc5 - pero no debería ser difícil convertirlo a cualquier herramienta de prueba que utilice.