PeterKellner.net » Reflection

Returning JsonResult From ASP.NET MVC 2.0 Controller and Unit Testing

Peter Kellner — Sat, 15 May 2010 04:19:31 +0000

* I’m adding this comment after the post has been written to let anyone coming here know of another great post that goes further to explain no only what I’ve done here, but also two other ways including Mock and using Json Serialization. The Post is written by Ashic Mahtab, aka “HeartattacK” on the forums. His well written and informative article is here: ASP.NET MVC – Unit Testing JsonResult Returning Anonymous Types.

This post will show how to return a simple Json result from an ASP.NET MVC 2.0 web project. It will show how to test that result inside a unit test and essentially pick apart the Json, just like a JavaScript (or other client) would do. It seems like it should be very simple (and indeed, once you see the answer it is), however there are lots of length discussions on the forums about this with all kinds of positives and negatives. The one I based my solution on is from Stack Overflow and is here.. My personal length discussion that did not really yield a satisfactory answer is here.

If you follow my method, you’ll be able to unit test a JsonResult created by an MVC asp.net web application.

Controller Side (Server)

Let’s get started. First thing we need to do is have a controller that return a JsonResult. Below is the one I’m currently working on. Let me show the code, then explain it.

public ActionResult Get(FormCollection form)
       {
           var query = new FolderPairQuery();
           if (form["query"] != null)
           {
               query = form["query"].FromJson();
           }

           if (form["start"] != null && form["limit"] != null)
           {
               query.Start = Convert.ToInt32(form["start"]);
               query.Limit = Convert.ToInt32(form["limit"]);
           }

           var results = FolderPairManager.I.Get(query);
           return Json(new
                           {
                               success = true,
                               rows = results,
                               total = query.OutputTotal
                           }, JsonRequestBehavior.AllowGet);
       }

This code is actually part of the file FolderPairController.cs. It returns an ActionResult (which in this case is JsonResult that derives from ActionResult). All the way to the return statement is just stuff that I do in my code to pull apart the passed in Request variables and process them. I only leave them in for context. It does not matter how you get your “results” and “total”, it just matters that you do. Then, the return statement is the part that is of interest. It’s basically returning an anonymous class which is actually a JsonResult. In System.Web.Mvc.Controller.cs, you will see that Json is defined as:

protected internal JsonResult Json(object data, JsonRequestBehavior behavior);

The first parameter is “object data” which means it can be anything, and in our case, it is an anonymous object.

Unit Test Side (Client)

So now, let’s take a look at the unit test itself. Again, let me show the code, then explain it.

[TestMethod]
public void InsertControllerTest()
{
    var pairName = string.Format("FolderPair {0}", 
        (new Random().Next(1, 10000)));
    var folderPairResults =
        new List()
            {
                new FolderPairResult
                    {
                        ActionTypeId = 1,
                        CheckFileContent = true,
                        ActiveForRunAll = true,
                        ExcludeHiddenFiles = true,
                        ExcludeReadOnly = true,
                        ExcludeSystemFiles = true,
                        FolderPairName = pairName,
                        LeftFolder = "left",
                        RightFolder = "right",
                        SaveOverWrittenRecycleBin = true,
                        UsersId = 1
                    }
            };



    string jsonInsert = JsonConvert.SerializeObject(folderPairResults);

    var form =
        new FormCollection
            {
                {"data", jsonInsert}
            };


    using (var controller = new FolderPairController())
    {

        controller.Insert(form);
    }

    // verify it got inserted.
    var queryObj = new FolderPairQuery { FolderPairName = pairName };
    string json = JsonConvert.SerializeObject(queryObj);
    var formGet =
        new FormCollection()
            {
                {"query", json}
            };

    using (var controller = new FolderPairController())
    {
        var jsonResult1 = controller.Get(formGet) as JsonResult;
        Assert.IsNotNull(jsonResult1,"jsonResult1 is null which is bad");
       
       
            List folderPairResults1 =
                (List)
                (jsonResult1.Data.GetType().GetProperty("rows")).GetValue(jsonResult1.Data, null);
            bool success =
                (bool)
                (jsonResult1.Data.GetType().GetProperty("success")).GetValue(jsonResult1.Data, null);
            int total =
                (int)
                (jsonResult1.Data.GetType().GetProperty("total")).GetValue(jsonResult1.Data, null);

            Assert.IsTrue(folderPairResults1.Count == 1, "Not one item returned");
            Assert.IsTrue(folderPairResults1[0].FolderPairName.Equals(pairName),
                "Wrong pairname returned");
    }
}

Up to the line “// verify it got inserted”, we simply are adding the record to the database in our unit test. I won’t go into detail about that in this post since it is not really the purpose here. I’m really just trying to show how to extract from the JsonResult the values that are returned from the server.

So, notice the line “var jsonResult1 = controller.Get(formGet) as JsonResult;”. This line simply calls the controller’s get method with the appropriate query parameters and returns us a JsonResult. Now, let’s look at how to get the data out of that. It’s really quite simple using reflection. Each of the following three lines pulls the data out so that at the end, we have our typed data for rows,total and count.

Hopefully, this will help you. Like I said in the beginning, there are lots of ways to do this. This just shows one that works for me.

Using Reflection in C# to Figure Out if an Integer List Has Values

Peter Kellner — Mon, 01 Jun 2009 19:04:31 +0000

So, I’ve struggled some with this and did not have much help with searching.

Here is the problem.

You have a declaration that looks like this:

        1: public partial class CompanyQuery   {

       2:       public List<int> CompanyTypeIds { get; set; }

       3: }

Then, you need to figure out if CompanyTypeIds is populated using reflection.

Here is the code:

       1: CompanyQuery query = new CompanyQuery;

       2: query.CompanyTypeIds = new List<int> {1,2,3,4}

       3:  

       4: foreach (var info in typeof(CompanyQuery).GetProperties())

       5:            {

       6:                 object[] attributes = info.GetCustomAttributes(typeof(ForceNoCompileColumnAttribute), true);

       7:                 if (attributes.Length > 0)

       8:                 {

       9:                     object value = info.GetValue(query, null);

      10:                     if (value != null && value.GetType() == (new List<int>()).GetType())

      11:                     {

      12:                         if (((List<int>)value).Count > 0)

      13:                         {

      14:                             forceNoCompile = true;

      15:                         }

      16:                     }

      17:                     else if (value != null)

      18:                     {

      19:                         forceNoCompile = true;

      20:                     }

      21:                 }

      22:            }

      23:

That’s basically it.

Hope this helps.

Using Method.Invoke to avoid a lengthy Case Statement in C# (Using Reflection)

Peter Kellner — Thu, 09 Apr 2009 22:02:56 +0000

So, I asked the following question in at http://forums.asp.net/t/1408631.aspx

The problem is, I’ve got 30 methods that all have the same signature, but have different implementations. Mike Banavige (the lead moderator at the forums) suggested I look at the following article on reflection: http://www.csharphelp.com/archives/archive200.html. Turns out, that helped my solve my problem exactly. Rather than go through a lengthy line by line explanation, I’m going to post some of my before and after code. It’s pretty clear what is happening, but I thought it would be nice to show a real example.

Before Code:

 private static void AddTemplateCode(string templateNumber, int indent, ICollection<string> newLines,FullMeta fullMetal)

            int iTemplateNumber = Convert.ToInt32(templateNumber);

            var sb = new StringBuilder(indent);

            sb.Append(' ', indent);

            string indentString = sb.ToString();

             // be nice to get rid of this ugly case statement.  Using it because I want to have a way to separate

             // methods associated with groups of methods.  that is, put Template11-15 in a separate file later.

            switch (iTemplateNumber)

                case 11:

                        Template11(newLines, indentString,fullMetal);

                        break;

                case 12:

                        Template12(newLines, indentString,fullMetal);

                        break;

                case 13:

                        Template13(newLines, indentString, fullMetal);

                        break;

                case 14:

Then, After, following the sample above:

 private static void AddTemplateCode(string templateNumber, int indent, ICollection<string> newLines,FullMeta fullMetal)

            int iTemplateNumber = Convert.ToInt32(templateNumber);

            var sb = new StringBuilder(indent);

            sb.Append(' ', indent);

            string indentString = sb.ToString();

            var processTemplate = new ProcessTemplateDynamic();

            processTemplate.DoIt(iTemplateNumber, newLines, indentString, fullMetal);

class with DoIt in it...>

using System;

using System.Collections.Generic;

using System.Reflection;

namespace ThreePLogicAccessCodeGen.Code

    public class ProcessTemplateDynamic

        internal void DoIt(int iTemplateNumber, ICollection<string> newLines, string indentString, FullMeta fullMetal)

            // Template11(newLines, indentString, fullMetal);

            string templateMethodName = String.Format("Template{0}", iTemplateNumber);

            var userParameters = new object[3];

            userParameters[0] = newLines;

            userParameters[1] = indentString;

            userParameters[2] = fullMetal;

try

                Type thisType = GetType();

                MethodInfo theMethod = thisType.GetMethod(templateMethodName);

                // that we have in this class that we don't want called.

                if (theMethod == null || (!CheckMethod(theMethod)))

                    throw new ApplicationException(string.Format("[e] Command <{0}> not supported.", templateMethodName));

                // Invoke the Method!

                theMethod.Invoke(this, userParameters);

            catch (ArgumentNullException e)

                // This exception is from the user entering in a null string on the command line

                throw new ApplicationException("[e] Please enter in a non-null string. (" + e.Message + ")");

            catch (TargetParameterCountException e)

                // This exception is thrown when the method is not passed the right number of parameters

                throw new ApplicationException(string.Format("[e] Command <{0}> requires parameters. ({1})",

                                                             templateMethodName, e.Message));

            catch (Exception e)

                // All other exceptions!

                throw new ApplicationException(string.Format("[e] General Exception:\n{0}", e));

Well, looking at it, seems maybe the Case statement is better, but the nice thing now is that each time I add a new template, I don’t have to make another case statement. That combined with it’s easier to make typos when you have a case statement so I’m sticking with my new solution here.

Hope this Helps!