This is easy to do by Mocking my CustomerRepository interface and using Rhino Mocks Callback method.

Based on the Nerd Dinner example I have a customer repository interface below.

public interface ICustomerRepository
{
    IQueryable GetAllCustomers();
    Customer GetCustomr(int id);
    void Add(Customer customer);
    void Delete(Customer customer);
    void Save();
}

To Mock this interface I have used a generic class factory developed by a colleague of mine that can dispense a Mock object into my customer controller with ease.

public TestCustomerController()
{
    _customerRepository = _mock.StrictMock();
    //Set up the class factory to dispense the mock objects
    GenericClassFactory.Dispenser = o => _customerRepository;
    _controller = new CustomerIdentityController();
}

Inside my controller I use the generic class factory to dispense, by default, real object or, if the dispenser is set, my mock object. This is done using the code below.

ICustomerRepository _customerRepository = GenericClassFactory.Get()

Finally I wrote my test method using Rhino Mocks. The create customer method creates a new customer object and adds it using the LINQ to SQL add method. I use the Rhino Mocks call back method to get and instance of the new client that was created by my CustomerController. After the client is added the client controller and LINQ to SQL verifies that there are no errors, which allows me to commit the new record using my repositories save method. This method uses the Callback method to to mimic the LINQ to SQL functionality by assigning a customer ID to the to the customer object which is then returned by my controller.

[TestMethod]
public void CreateCustomer_ValidData_ID_Expected()
{
    Customer customer = null;
    _customerRepository.Expect(o => o.Add(Arg.Is.NotNull))
                       .Callback((Customer c) =>
                                      {
                                          customer = c;
                                          return true;
                                      });
    _customerRepository.Expect(o => o.Save())
                       .Callback(() =>
                                      {
                                          customer.ID = 1;
                                          return true;
                                      });
    _mock.ReplayAll();
    var customerId = _controller.CreateCustomer("FirstName", "Surname");
    Assert.AreEqual(1, customerId);
}

This is nothing new but is a great way of mocking a method that does more then just return a value.

After deploying a solution to my web server I had a major issue where my JQuery $.post method was not working and was not giving me any errors. I immediately thought that there was an error in my server settings or something other then my code because I had no issues in my development environment.

It turned out to be an issue with routing! In my development environment the application was installed under the root directory (‘\’) where as on my server it was installed under a subfolder of the root directory (For example: ‘\test\’) thus the value I coded inside my $.post method was incorrect when deployed to my server.

In order to make it easy for me to deploy to any environment without changing my JQuery method each time I created this simple extension method for the HttpRequest class.

public static class HttpRequestHelper
{
    public static string AppendServerPath(this HttpRequest request, string path)
    {
        return request.ApplicationPath.EndsWith("/")
                   ? request.ApplicationPath + path
                   : request.ApplicationPath + "/" + path;
    }
}

So now inside my JQuery method all I have to do is call this method and append the exact path I wish to invoke.\

$.post("<%=Request.AppendServerPath("Test/Controller/DoSomething") %>", null, doSomeThing());

This also worked well inside my Site.Master where I ran into similar issues linking images, style sheets, JavaScript files, etc.

Wherever there is a link in my code I now call this extension method and know it will deploy almost everywhere.

Today the weather is terrible up in the alps and I managed to catch the flu so it was a good time to catch up on some personal projects. I was working on an ASP.NET MVC website for my sister and decided to use AJAX to populate a select list based on a selection in another select list. The ASP.NET MVC framework and JQuery makes it very easy to use AJAX to do this.

This is nothing new but very powerful if you want to create a nice fluent forms user interface. For the most part the process was very easy. However I ran into an issue where JQuery was treating the Json returned from the server as a string instead of an object. Thus making if difficult to retrieve the data I wanted. I will explain how I got around this later in the post.

The first thing you need to do create the server side method. This is very easy using ASP.NET MVC! Of course you would probably get your data from a database of some sort, however this is just a nice way of showing how its done. The method below gets a list of Foo objects based on the FooId parameter using LINQ’s Where method.

public class Foo
{
    public int FooId { get; set; }
    public string Name { get; set; }
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult GetFooList(int FooId)
{
    var fooList = new List();
    fooList.Add(new Foo { FooId = 1, Name = "One" } );
    fooList.Add(new Foo { FooId = 1, Name = "Two" } );
    fooList.Add(new Foo { FooId = 2, Name = "Three" });
    fooList.Add(new Foo { FooId = 2, Name = "Four" });
    return Json(fooList.Where(foo => foo.FooId == FooId).ToList());
}

Now for the client side code. On my page I have two select lists. One is a list of Id’s and the other is a list of names. When a user selects an id from the first select list the second is populated with the names relating to that id. The lists can be created easily using using the ASP.NET MVC Helpers or writing the HTML yourself.

1
2

Finally the JQuery code in order to add the functionality to the page. JQuery makes it easy to execute server side methods and receive Json. The code below binds the AJAX post method to the change event of the IdList select list. The post function has three variables; The sever method to execute, the parameters to pass as Json and the function to execute with the data returned from the server. You can either execute a named or a anonymous function. I chose the latter because I am not doing too much inside the function.

 $(function() {
        $("#IdList").change(function() {
            $.getJSON("/Controller/GetFooList", { FooId: $("#IdList").val() },
            function(fooList) {
                $("#NameList").empty();
                $.each(fooList, function(i, foo) {
                    $("#NameList").append(""+ foo.Name+ "");
                });
            });
        });
    });

The biggest issue I came across was, originally, the FooList Json was being represented as a string therefore the JQuery each method was iterating through each character of the string rather then each object. After a bit reading I came across the JSON.parse method in the JQuery library. This method parses the string to Json which means that the JQuery each method functions as I expected.

There we have it. Like I said nothing new here but interesting never the less.

The only thing I don’t like about this code is the append method in my JQuery. Surly there is a better way of adding options to a select element?

UPDATE 120/01/2011:  I have recently realised that using eval is bad! This is because it will evaluate ANY javascript returned from the server. Therefore there is a chance that someone with malicious intent could insert their own javascript into your request. So instead you should use jQuery’s getJSON method instead. The above code has been modified to use this function.

1. Convert an object model into a string in order to be sent
2. Receive a string and build an object model

The solution had to be robust because the transactional interface was very nit picky and the strings had to be 100% formed or it will throw all sorts of errors. It also had to be extensible allowing for more transactions to be added in the future.

I’m sure there are many ways to solve this problem however I wanted to make it scalable and declarative. So, along with a few pointers from my colleague Andrew, I decided to utilise method attributes, reflection and LINQ to solve the problem.

The following code is development code to prove a concept. Use at own risk

Building a string from an object model

Firstly I had to define my data transfer class, the restrictions imposed on its properties and the  wrapper template required by the transactional interface.

In the following example my class Foo contains the property Bar which as to be a maximum of 20 characters and must conform to the Regex displayed. Foo is also to be wrapped in the input template of max size 20.

[InputTemplate("Template Bar='{Bar}' End", 20)]
public class Foo
{
    [InputStringField(20, "^[a-zA-Z0-9]+$")]
    public string Bar { get; set; }
}

Using this approach I can define as may data transfer classes that are needed by my application and declare how they are to represented to the transactional interface.

The next step was to create a string builder that will convert the a data transfer object into a string based on the restrictions defined in the attributes of its class. I did this by reflecting the attributes and applying them to the properties of the data transfer object.

private static string BuildInputString(this T obj)
{
  var attrbutes = obj.GetType()
                     .GetCustomAttributes(typeof (InputTemplateAttribute), true)
                     .Cast();
    if (attrbutes.Count() != 1)
        throw new InvalidOperationException();

    string template = attrbutes.First().Template;

    foreach (var property in
      from prop in obj.GetType().GetProperties()
      let attributes = prop.GetCustomAttributes(typeof(InputStringFieldAttribute), true)
                           .Cast()
      where attributes.Count() > 0
      select new
             {
               PropertyInfo = prop,
               Attribute = attributes.First()
             })
    {
      if (property.PropertyInfo.GetValue(obj, null) == null)
        throw new NullReferenceException()
      string value = property.PropertyInfo.GetValue(obj, null).ToString();
      string name = property.PropertyInfo.Name;
      int length = property.Attribute.Length;

      if (value.Length > length)
        throw new InvalidOperationException();

      var regex = new Regex(property.Attribute.Format);
      if (!regex.IsMatch(value))
        throw new InvalidOperationException();

      template = template.Replace("{" + name + "}", value.PadRight(length).ToUpper());
    }
    return template;
}

The method above utilises anonymous types and reflection so it can be applied to any object that’s class definition uses the attributes defined above.

The string is then constructed using a helper function.

Foo foo = new Foo { Bar = "bar " };
string someString = foo.BuildInputString();

Building an object model from a string

Now we have to go back the other way. The transaction interface returns a string that will always conform to a set standard. So the output is declared in the same way that the input class was declared. For many of my data transfer scenarios the same class was used for input and output therefore the Input and Output attributes can be added to the same class and properties.

[InputTemplate("Template Bar='{Bar}' at Date='{Bar1}' End")]
[OutputTemplate(5)]
public class Foo
{
    [InputStringField(20, "^[a-zA-Z0-9]+$")]
    [OutputStringField(5, 0)]
    public string Bar { get; set; }    

    [OutputStringField(5, 1)]
    public string Bar1 { get; set; }
}

Now, just like the string builder above, we construct our Foo object list based on the constraints imposed on the properties in its attributes. In this example, the output string will always contain a counter of length 5 and will contain two ordered properties of max 5 characters.

public static IEnumerable BuildList(this string outputString) where T : new()
{
    if (string.IsNullOrEmpty(outputString))
        throw new InvalidOperationException();

    var obj = new T();
    var classAttrs = obj.GetType()
                        .GetCustomAttributes(typeof (OutputTemplateAttribute), true)
                        .Cast();

    if (classAttrs.Count() != 1)
        throw new InvalidOperationException();

    int count = int.Parse(outputString.Substring(0, classAttrs.First().CounterLength));

    for (int i = 0; i < count; i++)
    {
        obj = new T();
        foreach (var property in
            from prop in obj.GetType().GetProperties()
                let attributes =
                    prop.GetCustomAttributes(typeof (OutputStringFieldAttribute), true)
                        .Cast()
                        .OrderBy(a => a.Ordinal)
                where attributes.Count() > 0
                select new
                        {
                            PropertyInfo = prop,
                            Attribute = attributes.First()
                        })
        {
            string value = outputString.Substring(0, property.Attribute.Length);
            outputString = outputString.Remove(0, property.Attribute.Length);
            property.PropertyInfo.SetValue(obj, value.Trim(), null);
        }
        yield return obj;
    }
}
var fooList = someString.BuildList();

Method Attributes

I don’t think there is a need to show the attributes here as they are very simple. What you see in the constructor is what is stored in the properties of the attribute.

Conclusion

The solution above is a simplified version of what I am intending to develop, however it does show the concept of what I am doing. The solution is scalable and extensible because it can add more data transfer classes for different transactions as needed.