P&P Software Factories

CAB/SCSF Mocking Asynchronous Web Methods

Patrice Calve — Wed, 15 Oct 2008 12:35:19 GMT

Hi there,

How do you mock an asynchronous web method (web service) call? You can skip the background and move on directly to the solution...

Background:

Visual Studio 2005
CAB/SCSF May 2007
C# 2.0
Rhino Mocks (version 3.5 for 2.0)

In a CAB/SCSF project I'm working on, I'm testing a Presenter's method "OnViewReady". In my implementation, this OnViewReady does basically 2 things:

Tells the View to Show a "Loading..." message to the user
Issues an asynchronous call to a Web Service

When the call is returned from the Web Service, the Presenter tells the View to Show the message returned by the Web Service.

The method looks like this:

Solution

The solution is threefold:

Make the Web Service Mocking Friendly ...
Make the presenter "interface friendly" ...
Fine tune the Test Method! :) ...

Web Service Mocking friendly

Making the Web Service Mocking friendly was not so evident. Well, at least, the "mocking async methods" part.

To mock a Web Service, you have to extract an interface from the generated web service code (reference.cs), and make the web service code inherit from that interface. You could make the web service "reference.cs" implement the interface, but may kill that code when you "update web reference". The trick is to add a second "partial class" that will inherit from that interface.

Here goes:

In Visual Studio,
In your MyAppModule's project, click Add Web Reference and follow the wizard
Open the Reference.cs in the IDE (Show All Files)
Right Click on the public partial class MyWebService and choose "Refactor -> Extract interface"
This will create a IMyWebService interface with all of the methods from you Web Service.
Now, add a new class "MyWebService", make sure the namespace and class declaration is the same as the "real" web service. "public partial class MyWebService", but make it implement the interface you created.

This is the web service's signature (in my example, the "MyWebService" is called "GeneralWS")

public partial class GeneralWS : System.Web.Services.Protocols.SoapHttpClientProtocol { .. }So nothing changed.

This is the interface extracted:

    public interface IGeneralWS
    {
        void CancelAsync(object userState);
        string Ping();
        void PingAsync(object userState);
        void PingAsync();
        event PingCompletedEventHandler PingCompleted;
        string Url { get; set; }
        bool UseDefaultCredentials { get; set; }
    }

This is the second partial class. Note that there's no code, just the interface:

    public partial class GeneralWS : IGeneralWS
    {
        //look ma, no hands
    }

Now, if you open the reference.cs, check the PingCompletedEventArgs code: The constructor is "internral" ! So, this means that we can't mock the async method because we can't create a new PingCompletedEventArgs when we mimic the callback.

Again, what you do, is create an interface and leverage the "partial" declaration of the PingCompletedEventArgs. Repeat the steps for the Web Service class, but this time, for the EventArgs.

Here are my results:

    public interface IPingCompletedEventArgs
    {
        string Result { get; }
    }

Add the second "partial" class:

    public partial class PingCompletedEventArgs : IPingCompletedEventArgs
    {
        public PingCompletedEventArgs(string results) : 
                base(null, false, null)
        {
            //We're hard coding the results to an 1-item array (object) since we know 
            //that the web service's Ping method returns a string.
            this.results = new object[1];
            this.results[0] = results;
        }
    }

Ok, that takes care of the "Web Service" part. At this point, you can run the solution and it will work. And if you update the web reference, you won't loose a thing.

Making the presenter "interface friendly"

Making the presenter "interface friendly" is the well-known "multiple constructor" algorithm.

In a classic web service call, your method will be like this:

        private void doSomethingWild()
        {
            GeneralWS gws = new GeneralWS();
            string returnValue = gws.Ping();
            View.ShowMessage(returnValue);
        }

In a "mocking friendly" class, you can't do that. The class must work with an interface instead and the mocking framework will "mock" that interface for you.

4 steps:

Add a private variable of type Interface (that you created earlier)
Add a default constructor that will attach a "real web service" to that private interface variable
Add a "mockig friendly" constructor where pass in in the mocked interface (this is the real trick)
Change the call to the web service to not create a reference to the "real web service", but simply re-use the private variable of type interface

here's a sample from my presenter (construction part):

    public partial class HelloWorldViewPresenter : Presenter<IHelloWorldView>
    {
        private PeopleCentralGeneral.IGeneralWS _gws;
 
        //default parameter-less Presenter, for normal code execution
        public HelloWorldViewPresenter()
        {
            _gws = new GeneralWS();
            _gws.PingCompleted += new PingCompletedEventHandler(gws_PingCompleted);
 
        }
        //special constructor for "Mocking Friendlyness"
        public HelloWorldViewPresenter(IGeneralWS gws)
        {
            _gws = gws;
            _gws.PingCompleted += new PingCompletedEventHandler(gws_PingCompleted);
 
        }
        ...
        /// <summary>
        /// This method is a placeholder that will be called by the view when it has been loaded.
        /// </summary>
        public override void OnViewReady()
        {
            View.ShowMessage("Loading...");
            base.OnViewReady();
 
            pingAsync();
 
        }
        private void pingAsync()
        {
            //note that I'm not creating a new reference to the web service but re-using the interace instead..
            //proper coding would check that _gws isn't null, of course ;)
            _gws.PingAsync();
        }
 
        private void gws_PingCompleted(object sender, PingCompletedEventArgs e)
        {
            View.ShowMessage(e.Result);
        }
        ...
}

Fine tuning the Test Method

Fine tuning the Test Method for async web methods requires another trick with the Web Service.

Finally, the Test Method !

In the HelloWorldViewPresenterTest.cs, here's the Test Method for the OnViewReady:

        /// <summary>
        ///A test for OnViewReady ()
        ///</summary>
        [TestMethod()]
        public void OnViewReadyTest()
        {
            MockRepository repo = new MockRepository();
 
            //the mocked general web service
            IGeneralWS genWS = repo.StrictMock<IGeneralWS>();
 
            //the mocked view
            IHelloWorldView view = repo.StrictMock<IHelloWorldView>();
            Support.TestableRootWorkItem workitem = new Support.TestableRootWorkItem();
 
            //this will be used to simulate the call back from the web service
            Rhino.Mocks.Interfaces.IEventRaiser pingCompletedRaiser;
 
            using (repo.Record())
            {
                Expect
                    .Call(delegate { view.ShowMessage("Loading..."); });
 
                //Expect that the PingAsynch() method will be called
                Expect
                    .Call(delegate { genWS.PingAsync(); });
 
                //Provide the entry point for the call back.
                genWS.PingCompleted += null;
 
                pingCompletedRaiser = LastCall
                    .IgnoreArguments()
                    .GetEventRaiser();
 
                Expect
                    .Call(delegate { view.ShowMessage("Pong"); });
            }
 
            HelloWorldViewPresenter target = new HelloWorldViewPresenter(genWS);
            target.View = view;
            target.WorkItem = workitem;
 
            using (repo.Playback())
            {
                target.OnViewReady();
 
                //This "new EventArgs" would be impossible without the second partial class
                PingCompletedEventArgs args = new PingCompletedEventArgs("Pong");
 
                //make the callback call....   
                pingCompletedRaiser.Raise(genWS, args);
 
                //we're done!
            }
        }

I hope this info will help you in your quest for building better applications.

Patrice Calvé

Failed to access IIS metabase

Patrice Calve — Sat, 16 Jun 2007 00:18:50 GMT

Ha man !!!!

2 evenings lost trying to make this darn simple web app. It's a Web Client Software Factory - June 2007 project on Vista box and whenever I was running the web app, I would be getting:

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.Web.Hosting.HostingEnvironmentException: Failed to access IIS metabase.

The process account used to run ASP.NET must have read access to the IIS metabase (e.g. IIS://servername/W3SVC). For information on modifying metabase permissions, please see http://support.microsoft.com/?kbid=267904.

Source Error:

Server Error in '/DevelopmentWebsite' Application.

Failed to access IIS metabase.


            Line 98:             else
Line 99:             {
Line 100:                configuration = WebConfigurationManager.OpenWebConfiguration(context.Request.ApplicationPath + "/" + configFilePath.Replace(context.Request.PhysicalApplicationPath, ""));
Line 101:            }
Line 102:            return configuration;

The solution is darn simple: run Visual Studio as an admin. I changed my shortcut in my Quick Launch to "Run as Administrator". Being an administrator on my machine wasn't enough, I had to be an admin admin!

The metaacl.vbs and adsutil.vbs aren't very usefull here as I'm running the Visual Studio WebServer.

Pat

Training on CAB/SCSF by David Platt

Patrice Calve — Fri, 09 Mar 2007 18:48:00 GMT

I'm finishing up my 4 day training course on CAB/SCSF by David Platt.

It was a great class and encourage others to try it out.

Sir, if you're reading this: thanks again.

Pat

Providing historical information to classes

Patrice Calve — Thu, 08 Mar 2007 19:55:00 GMT

Last year, I was working on a CAB/SCSF project that had to deal with concurrency (when a user tries to save changed data, but data on the server was already changed by someone else).

We used optimistic concurrency and tried to auto-resolve the issues whenever possible and where the business rules allowed it. Whenever auto-merge was not possible, we had to inform the user and provide a mechanism to allow the user to first discover the conflicts and choose the best answer.

Anyway, we had to deal with 3 information:

The values changed by the user
The original values
The latest server values

On the client side, we kept 1 and 2 in separate variables:

Customer _customer;
Customer _customer_original;

Something trivial.

However, I didn't like the fact that for each class, the original/updated state handling had to be handled by objects outside the class's scope (basic rule of thumbs).

The project was canned and never had the chance to work on a solution, until now...

I created a generic Historical<T> class that any business entity class could inherit.

using System;
using System.Collections.Generic;
using System.Text;

namespace ClassLibrary1
{
   public class Historical<T>
   {
      /// <summary>
      /// Lorem Ipsum about the Original Value
      /// </summary>
      private T _original = default(T);
      private bool _initializing = true;
      private object lockObject = new object();
      internal bool Initializing
      {
         get { return _initializing; }
         set
         {
            lock (lockObject)
            {
               _initializing = value;
               if (_initializing == false)
                  makeACopy();
            }
         }
      }

      private void makeACopy()
      {
         if (_original == null)
            if (!_initializing)
               _original = (T)this.MemberwiseClone();
      }

      public Historical()
      {
         _original = default(T);
      }

      public T OriginalValues
      {
         get { return _original; }
      }

}
}

Now, for the Business Entity Class, all I have to do is to inherit from this Historical class:

public class Class1 : Historical<Class1>
{
private string _name = "Not Set";

   public string Name
   {
      get { return _name; }
      set {_name = value; }
   }
}

I was presently supprised to see that it was possible (in C#) to declare a class "Class1" that inherits from a generic class "Historical" that referenced the child class! Kind of a chicken and egg mystery broken !

Now, let's go back to the Historical<T> class, notice how the bool Initialized property is Internal. This means that to benefit from the OriginalValues can only be given if the Initializing is set to false by an internal class. This fits well in the CAB world where the Business Entity Classes are "pictures" of data on a server; A piece of code needs to fetch the data from the server, create the Business Entity Class and fill in the values.

Here's an example of the data store class:

using System;
using System.Collections.Generic;
using System.Text;

namespace ClassLibrary1
{
   public static class Store
   {
      public static Class1 GetClass1(int id)
      {
         //Get data from server and then set the values...

         Class1 c = new Class1();
         c.Name = "Pat";
         c.DateOfBirth = new DateTime(2000, 1, 2);

         //We're done with setting the values...
         c.Initializing = false;

         return c;
       }
   }
}

So, for a "client dev" point of view, the Class1 is very simple and easy to work with, allows modification to the data, while keeping track of the original values. This "store" is a bad example

And quite frankly, we could go a step further and actually make the class1 partial, create a second "partial" class that inherits the Historical<T>. This would make the original class1 "code generator friendly".

This strategy is CAB/SCSF friendly because:

The Business Entity class is easy to use from the GUI (add/update)
Adds benefits for handling concurrency
Non-intrusive

Wadaya think?

Pat