This past week I started working on a new user interface framework for an application, and I wanted to do it “right” and do it with TDD.  I’d tried NUnitAsp for this before and ran into problems, but I thought I’d give it another shot.

The first thing I did was to implement a base test class for creating self-contained tests using Cassini based on the ideas proposed by Scott Hanselman and expanded by Anders Noras since I needed these tests to be able to be run from a build server, and I didn’t want to worry about dependencies on iis and virtual directories, etc.

Everything started off good, but as the testing got hot and heavy, I found that I really needed to be able to manipulate items in the Session or HttpContext to setup some of my test scenarios properly. Now, I’d seen this done with a few other techniques, but none that actually used NUnitAsp and I couldn’t figure out how to make use of them.

Here’s what I ended up doing. Based on Scott and Anders examples, I realized that it would be possible to inject an aspx file into the virtual web that Cassini was creating….which meant any calls I made to it would run in the web’s application domain. So, I created a Setup.aspx file that would allow me to make requests to it and pass in a static method that I wanted to call, and as a result, any code that ran inside of it would run inside the web’s application domain and have access to the Session and HttpContext. Awesome!

Here’s the SelfContainedWebFormTestCase class abstracted from Anders’ example (code for injecting the file in bold):

   1:  using System;

   2:  using System.Diagnostics;

   3:  using System.IO;

   4:  using Cassini;

   5:  using NUnit.Framework;

   6:   

   7:  namespace UnitTests 

   8:  {

   9:   

  10:    [TestFixture]

  11:    public class SelfContainedWebFormTestCase : NUnit.Extensions.Asp.WebFormTestCase 

  12:    {

  13:      private Server  webServer;

  14:      private int     webServerPort = 8086;

  15:      private string  webServerVDir = "/";

  16:      private string  tempPath = AppDomain.CurrentDomain.BaseDirectory;

  17:      private string  tempBinPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,"bin");

  18:      private string  webServerUrl;

  19:      private string  aspxPath = "";

  20:   

  21:      

  22:      public SelfContainedWebFormTestCase(

  23:        string aspxPath

  24:        )

  25:      {

  26:        this.aspxPath = String.Format(@"..\..\..\{0}", aspxPath);

  27:      }

  28:   

  29:      public virtual string BaseUrl

  30:      {

  31:        get{ return webServerUrl; }

  32:      }

  33:   

  34:   

  35:      [TestFixtureSetUp]

  36:      public void TestFixtureSetUp() 

  37:      {

  38:        Directory.CreateDirectory(tempBinPath);

  39:        foreach(string file in Directory.GetFiles(tempPath,"*.dll")) 

  40:        {

  41:          string newFile =

  42:            Path.Combine(tempBinPath,Path.GetFileName(file));

  43:          if (File.Exists(newFile)){File.Delete(newFile);}

  44:          File.Copy(file,newFile);

  45:        }

  46:        foreach(string file in Directory.GetFiles(aspxPath,"*.aspx")) 

  47:        {

  48:          string newFile = 

  49:            Path.Combine(tempPath,Path.GetFileName(file));

  50:          if (File.Exists(newFile)){File.Delete(newFile);}

  51:          File.Copy(file,newFile);

  52:        }

  53:   

  54:   

  55:        //Start the internal Web Server

  56:        webServer = new Server(webServerPort,webServerVDir,tempPath);

  57:        webServerUrl = String.Format("http://localhost:{0}{1}", webServerPort, webServerVDir);

  58:        webServer.Start();

  59:   

  60:        // Let everyone know

  61:        Debug.WriteLine(

  62:          String.Format("Web Server started on port {0} with VDir {1} in physical directory {2}",webServerPort,webServerVDir,tempPath));

  63:      }

  64:   

  65:   

  66:      public void InjectFile(

  67:        string filename

  68:        )

  69:      {

  70:        FileInfo fileInfo = new FileInfo(@"..\..\" + filename);

  71:        if ( fileInfo.Exists )

  72:        {

  73:          string file = fileInfo.FullName;

  74:          string newFile = Path.Combine(tempPath,Path.GetFileName(file));

  75:          if ( File.Exists(newFile) ){ File.Delete(newFile); }

  76:          File.Copy(file, newFile);

  77:        }

  78:      }

  79:   

  80:   

  81:      [TestFixtureTearDown]

  82:      new public void BaseTearDown() 

  83:      {

  84:        base.BaseTearDown();

  85:        try 

  86:        {

  87:          if ( webServer != null ) 

  88:          {

  89:            webServer.Stop();

  90:            webServer = null;

  91:          }

  92:          Directory.Delete(tempBinPath, true);

  93:        } 

  94:        catch {}

  95:   

  96:      }

  97:    }

  98:  } 

This is the generic Setup page that I am injecting. Query String should take the form of op=[Classname].[Static Method name]:

   1:      public class Setup : System.Web.UI.Page

   2:      {

   3:          protected System.Web.UI.WebControls.Label Label1;

   4:    

   5:          private void Page_Load(object sender, System.EventArgs e)

   6:          {

   7:            string op = Request.QueryString.Get("op");

   8:            if ( op != null && op.Length > 0 ){ Call(op); }

   9:          }

  10:   

  11:   

  12:          public void Call(

  13:           string op

  14:          )

  15:          {

  16:            string[] expression = op.Split('.');

  17:            Type t = Type.GetType(String.Format("{0}.{1}", MethodBase.GetCurrentMethod().DeclaringType.Namespace, expression[0]));

  18:            t.InvokeMember(expression[1], BindingFlags.Default | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, new object[]{});

  19:          }

  20:   

  21:   

  22:          #region Web Form Designer generated code

  23:          #endregion

  24:      }

And a sample test case (the static method will be called by the Setup.aspx via the Browser.GetPage call on line 12): 

   1:      public static void SessionValuesCreatedByCallToSetupPageAreUsedByPageUnderTest_Setup()

   2:      {

   3:        // This code will be run from the call to Setup.aspx and inside the web's application domain.

   4:        HttpContext.Current.Session["Label1"] = "Value from setup.";      

   5:      }

   6:   

   7:   

   8:        [Test]

   9:        public virtual void SessionValuesCreatedByCallToSetupPageAreUsedByPageUnderTest()

  10:        {

  11:        this.InjectFile("Setup.aspx");

  12:        Browser.GetPage(this.BaseUrl + "Setup.aspx?op=Default.SessionValuesCreatedByCallToSetupPageAreUsedByPageUnderTest_Setup");

  13:        Browser.GetPage(this.BaseUrl + "Default.aspx");

  14:        ButtonTester button1 = new ButtonTester("Button1", CurrentWebForm);

  15:        LabelTester label1 = new LabelTester("Label1", CurrentWebForm);

  16:   

  17:        button1.Click();

  18:        NUnit.Framework.Assert.AreEqual("Value from setup.", label1.Text);        

  19:        }

      Where default page has a Label and a Button. Clicking the button populates the Label text from the Session:

   1:      public class _Default : System.Web.UI.Page

   2:      {

   4:      protected System.Web.UI.WebControls.Button Button1;

   5:      protected System.Web.UI.WebControls.Label Label1;

   6:    

   7:          private void Page_Load(object sender, System.EventArgs e)

   8:          {

  14:          }

  15:   

  16:          #region Web Form Designer generated code

  17:          #endregion

  18:   

  19:      private void Button1_Click(object sender, System.EventArgs e)

  20:      {

  21:        this.Label1.Text = (string) Session["Label1"];

  22:      }

  23:      }

Sometime back I started a personal blog over on msn spaces in addition to my more tech-focused blog here. Being the lazy guy I am and not wanting to have to open two different tools to post to both my technical blog here and my personal blog over there, one of the first things I did was to find out if spaces supported any of the blogging APIs.

A quick google search brought me to Dare's disappointing explanation that the MSN team wasn’t fond of the existing APIs and were exploring options.

Ok, that's fine, I thought. It's in beta, they're figuring things out. I can wait a month or two. Well, I got tired of waiting, so I rolled my own makeshift solution. I’ve put it in a gotdotnet workspace in case anybody else finds it useful.

Introducing PostToSpaces - a MetaWeblogAPI web service endpoint that allows users to submit posts to an MSN Space.

Get it here (via gotdotnet): Download

What is it? It’s a simple little web service that simply intercepts a MetaWeblog.newPost method call, creates an SMTP mail containing the post, and sends it to the MSN Spaces email address configured for Email Publishing for the space. No more, no less.

To use it, you’ll need a server to host the service that has a configured smtp server. Follow the instructions below.

INSTALLATION INSTRUCTIONS
-------------------------
1. Copy the service to the desired server and configure a virtual directory to point to it.
2. Change the config values in the web.config to point to the appropriate SmtpServer
   and to use your Send From Email Address as configured in your MSN space.
3. When calling the newPost method, parameters should represent the following:
    - blogid = [not used]
    - username = [MSN space name]
    - password = [MSN space email publishing secret word]
    - post = [struct containing your post title and description]
    - publish = [not used]

In a follow up post, I’ll talk about how I hooked PostToSpaces up with BlogJet for unified posting goodness…

This time from the perspective of ROI: Free Time is Not Free

(via Rob Chartier)

http://departments.bloomu.edu/english/111/pullmethod.htm

Sounds familiar doesn’t it?

It seems that Scrum meetings (just the meetings – not the full-scale methodology yet) are starting to catch on at my workplace. However, I’ve heard grumblings from co-workers on other teams that talk about how their “scrums” are droning on and on and not being very productive. I think this may be due to a lack of understanding or clear definition by the scrum leader as to what the meeting should look like.

I found an excellent article that sums it up in a nutshell…

Scrum meetings defined:

The Meeting

As an integral part of the Scrum methodology, teams meet frequently – daily or every other day. The meeting usually lasts fifteen minutes, occasionally longer, but never more than thirty minutes. This provides enough time to address obstacles, but does not allow time to define solutions. Problem-solving discussion is held later, where only those who are involved in the problem attend. Having the meeting focus on raising but not solving issues is definitely a factor in making these meetings effective.

During the meeting, the Scrum Master (usually the team leader) asks three questions of each team member. Each team member answers those three questions. That’s it. Meeting over.

Here are the three questions:

1. Relative to the Backlog (list of incomplete tasks), what have you completed since the last meeting?

2. What obstacles got in the way of your completing this work?

3. Relative to the Backlog, what specific things do you plan to accomplish between now and the next meeting

I also like the XP concept of standing up during these meetings to reinforce the idea of keeping them short. I think, in the end though, it all rests on the meeting facilitator’s shoulders to keep the meetings efficient and meaningful.

This is one of the best papers I've ever read for making the case for Agile Methodologies. It's long, but well worth it. So fight through (that means you, Scott).

Here's an excellent excerpt about the problem with doing up-front requirements sign-off (i.e. taking the Waterfall approach):

Here's the problem. Suppose you say to customers, "Okay, we're going to give you a system to solve XYZ problem. We're going to gather all of the requirements, analyze them, and write them down in a big book for you to review. Your job is to make sure we have gotten everything right, because once we start coding, you can't make any changes. So we're going to ask you to sign-off on the requirements, and then if you want any changes, we'll estimate the cost and you'll have to approve the change.

Now let's assume that the customers don't really know what they need to solve XYZ problem (that's why they asked you to solve it). Thus, they are worried that they might forget to tell you something as you gather requirements, so they try to be very thorough. The process does not ask them to be sure that they need something when they put it on the requirements list; the process encourages them to put everything on the list unless they are certain they will not use it.

Is it any wonder that a system developed under these rules will have many features that end up in the rarely-if-ever used category? In our standard approach to defining scope, we build in tremendous incentives for excessive scope. Freezing scope usually has exactly the opposite effect that we desire. It does not prevent scope creep; it causes scope bloat.

FYI, I ran across this via another excellent post by Darrell Norton with a response to concerns about agile approaches. If you are interested in this subject, you should read that as well.

I've always felt that there are really two main problems with searching the web - either you can't find what you're looking for because the content doesn't exist / hasn't been indexed, or you can't find what you're looking for because too much content exists.

The first issue seems to be the one that gets the most focus, but I find the second equally frustrating.  Well, Scott Mitchell came up with an idea that touches on both ends of the problem (a twofer, if you will).

He proposes using a gmail account as a knowledge base to subscribe to specialized content such as USENET groups, forums, Yahoo! Groups, etc, and then taking advantage of their mass storage and excellent search capability to perform focused searches on content that is often missed by search engine spiders.  Brilliant!

A very nice little Google Suggest-like control:  http://www.codeproject.com/jscript/jsactb.asp