Okay, so, have you heard about NUnit attributes, and how they’re awesome?
Sure you’ve heard of Setup, Test, TestFixture, and TearDown? But how about Values? How about Range?

The Values attribute allows you to run the same test several times with different values. It makes it where you’re not doing something crazy like copy and pasting the same test, over and over again! I was close to that situation, but it hurt my soul too much to do that. So, in order to save my soul, I had to seek a path for redemption. Here’s what I found:

Okay, to try this, you may need to set up a sample test. If you need to start from scratch, check out my End-to-End Example: http://thetestingblog.com/2009/09/10/selenium-rc-in-c-using-nunit-an-end-to-end-example/

My example test verifies that the text “Daniel Brown” is present on the main testing blog page–a simple pass or fail. But imagine we wanted to run the test 3 times, each time verifying the presence of a different Testing Blog author. Here’s how we would do it using the Values attribute:

        [Test]
        public void ValuesTest([Values("Daniel Brown", "Marisa Seal", "Josh Carroll")] string textPresent)
        {
            selenium.Open("http://www.google.com");
            selenium.Type("q", "thetestingblog.com");
            selenium.Click("btnI");
            selenium.WaitForPageToLoad("60000");
            Assert.IsTrue(selenium.IsTextPresent(textPresent));
        }

As you can see, we’re basically passing the argument “textPresent” into the method. The values are what you want the argument to be. For each value, run the test once with “textPresent” = to that value:
[Values("Daniel Brown", "Marisa Seal", "Josh Carroll")] string stringPresent

So, in the case of this test; here’s how it would run:
SetupTest();
ValuesTest(“Daniel Brown”);
TeardownTest();
SetupTest();
ValuesTest(“Marisa Seal”);
TeardownTest();
SetupTest();
ValuesTest(“Josh Carroll”);
TeardownTest();

This is how it looks in the test runner:

Okay, that wasn’t too bad.  Now, let’s go a crazy.  Let’s get nuts.  Potentially throwing best practices to the wind.  We’re going make this example where it pulls the values from a text file instead of hard coding them.  To do that, let’s add a text file to our project:

Right click on your project (“TestingBlogSeleniumRc”) in the Solution Explorer -> Add -> New Item…

Select Text File and call it ValueList.txt

Open the file in your editor and type the three values into the text file.  One per line:

Next we want to make sure that the text file is copied over into the bin folder on build.

Right click on your project (“TestingBlogSeleniumRc”) in the Solution Explorer and select Properties.  Then select Build Events.  Under the Pre-build event command line: (or post-build; it doesn’t matter) paste in:

copy "$(ProjectDir)ValueList.txt" "$(TargetDir)"

Our test is going to be looking for ValueList.txt so that copy command assures that it’s in the same folder as the test dll.

(FULL CODE EXAMPLE BELOW)

• We need to add a reference to System.IO
• Next we’re going to add a global string array to our class called textPresentList
• We are going to read the ValueList.txt file into an array in our setup.  As coded, it should only be read in the first time the SetupTest() method is run.  If you’re a Unit Test purist, you could easily change it to read the file in every time, but I thought it seemed like a waste.
• Next we need to add the Range attribute to a copied and renamed version of our first test.  The range should be hard coded from 0 to 2.  (I tried to do something clever like put it from 0 to textPresentList.Length-1, but the compile wouldn’t have it.  These NUnit attribute values, it appears have to be somewhat static.  This kludge that I’m showing is way to get around the static nature if only a little bit.  This way the values can be dynamic even if the number of values can’t be.  By the way, if anyone has a better idea to make it more dynamic, please post it.)
• Change the selenium.IsTextPresent(textPresent) to selenium.IsTextPresent(textPresentList[i]).
• Then Compile and Run.

You won’t be able to see the values from the file in the Test Runner, but you could write the value translations to the console so that you could see which index corresponds to which value:
Console.WriteLine("Index " + i +": " + textPresentList[i]);

In the Test Runner, select the Text Output tab to view the output:

The whole point of this post is not to show you what to do, but instead to open up your mind to possibilities.  NUnit has some cool functionality, and most of us never scrape the surface of it’s potential.  I challenge you to go and explore the various attributes available for yourself.  Here’s the link: http://nunit.org/index.php?p=attributes&r=2.5.7

Remember upgrade your NUnit to the newest version.  Chances are that you’re not current.

FULL CODE:

using System;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
using NUnit.Framework;
using Selenium;

namespace TestingBlogSeleniumRc
{
	[TestFixture]
	public class FirstTest
	{
		private ISelenium selenium;
        private string[] textPresentList;

		[SetUp]
		public void SetupTest()
		{
            if (textPresentList == null)
                textPresentList = File.ReadAllLines("ValueList.txt");
			selenium = new DefaultSelenium("localhost", 4444, "*iexplore", "http://www.google.com/");
			selenium.Start();
		}

		[TearDown]
		public void TeardownTest()
		{
		    selenium.Stop();
		}

        [Test]
        public void DynamicValuesTest([Range(0,2)] int i)
		{
			selenium.Open("http://www.google.com");
			selenium.Type("q", "thetestingblog.com");
			selenium.Click("btnI");
			selenium.WaitForPageToLoad("60000");
            Console.WriteLine("Index " + i +": " + textPresentList[i]);
            Assert.IsTrue(selenium.IsTextPresent(textPresentList[i]));
		}
        [Test]
        public void ValuesTest([Values("Daniel Brown", "Marisa Seal", "Josh Carroll")] string textPresent)
        {
            selenium.Open("http://www.google.com");
            selenium.Type("q", "thetestingblog.com");
            selenium.Click("btnI");
            selenium.WaitForPageToLoad("60000");
            Assert.IsTrue(selenium.IsTextPresent(textPresent));
        }
	}
}

Déjà vu all over again! Another basic Selenium example. What the heck!? Can’t this guy do anything else?

Well, I agree this is somewhat repetitive, but I hope that this sequel will be in the league of Empire Strikes Back or Star Trek: The Wrath of Khan. Both movies, though they were sequels, were arguably greater than the originals. These sequels introduce us to the likes of Ricardo Montalban playing “Khan” and Billy Dee Williams playing “Lando Calrissian”.  And of course,  a muppet playing “Yoda”.

Of course, many sequels start off with the desire to be Empire, and instead they end up being:

• Caddyshack II
• Beastmaster 2: Through the Portal of Time
• Speed 2: Cruise Control
• Batman and Robin (No, we don’t need nipples on the Batman suit, Joel Schumacher.  But thanks for asking.)
• Mannequin: On the Move.
• Or the biggest sacrileges of all time Godfather III
• And Episode I (Empire, it is not!).

My hope is that this post doesn’t suck like those movies.  At the very least it’s nipple and Clooney free.

• Selenium RC
• Firefox
• Selenium IDE
• Java Runtime Environment (You should already have this)
• Visual C# 2008 Express Edition (Only get this if you don’t have a full version of Visual Studio)

Selenium RC
-No installation necessary. Just find a permanent location and unzip it there. I unzipped mine at C:\ just to make things simple

Firefox, Visual Studio Express, and Java
-Just run the respective installs with all defaults selected.

Selenium IDE
-To install, right click on the file and select “Open With…”
-Select Firefox in the programs list. If it’s not in the immediate menu, browse to it. (default location should be “C:\Program Files\Mozilla Firefox\firefox.exe“
-When Firefox launches, click button in the dialog box that says “Install Now”.
-After the install of the plug-in, hit the “Restart Firefox” button when you see it.

Okay, so, now that you have the tools, we’re going to record a simple test in Selenium IDE. Even though we want to eventually run the test in Selenium RC, Selenium IDE is a great tool for getting the basic test recorded since it’s all UI point and click.

• Start up Firefox.
• Click on the “Tools” menu and click on “Selenium IDE”
• (Take your time to explore the Selenium IDE form)
• Notice that it’s already recording.  The red circle button on the right side is pressed in:
• Type “www.google.com” the main Firefox browser address bar and navigate to it.
• In the search box, type in “thetestingblog.com” and hit the “I’m Feeling Lucky” button.
• Notice in your Selenium IDE window that steps are being recorded.
• With any luck, you hopefully landed on this blog’s home page.
• Highlight the text “Daniel Brown” on the page, right click.  You should select the option that says “VerifyTextPresent Daniel Brown”.  See below:

• Okay, we got our test recorded.  Now let’s run it to make sure it passes.
• Unclick the red circle button to turn off recording.
• Click on the green play triangle with the single bar to run the test

• All green, it passed.  Good.
• Now we want to convert this test to C#.
• Select “Options ->Format -> C# – Selenium RC” from the Selenium IDE window.

• Next select all the C# code and copy it.

• Open up Visual Studio
• Select “File ->New ->Project”
• In the New Project window under project types, select “Visual C# ->Windows”
• Select the “Console Application” Template and name it something like “TestingBlogSeleniumTest” and click “Ok”.
• It will create the project along with a file called “Program.cs”. Paste your SeleniumIDE test into Notepad. You’re going to take pieces out of the test and put it in “Program.cs”.

1. Add the using references from the SeleniumIDE test.  Replace any that are there.
2. Add the “ISelenium” and “StringBuilder” object references inside the Main() method.  As you see, I removed the “private” access control prefixes.  We don’t need them.
3. Add the body of the SetupTest() method after the object references.  (I put a comment to designate that it was part of the setup.)
4. Change “*chrome” to “*iexplore” for Internet Explorer.  Use “*firefox” for Firefox.  (There are other browser options, but those work best.)
5. Change the URL to the site you start your test on.  In this case, change that URL to “http://www.google.com/” since we’re starting from Google.

6. Paste body of the TheUntitledTest() method into the Main() method.

7. Paste body of the TeardownTest() method into the Main() method.

8.  Get rid of the Try/Catch blocks on Teardown.

9. Get rid of the StringBuilder references.

10.  Get rid of the Try/Catch block in the test body, replacing it with an if statement that writes to the console window if true (See my code below).  Notice that I have to cast the Selenium.IsTextPresent statement as a boolean.  I don’t understand why it doesn’t work without it because the return type for that method should be boolean.  But whatever.  I’m just dummy tester; what do I know?

• Next we need to add all the references so this thing will run.
• Go to the solution explorer, and right click on the “References” and select “Add Reference…”
• Hit the “Browse” tab and navigate to where you unzipped your SeleniumRC files.  Look in the dotnet client driver folder.  Here’s the path to mine:

C:\selenium-remote-control-1.0.1\selenium-dotnet-client-driver-1.0.1\

• Once you navigate to where the proper *.dlls are, select all of them and click “OK” to add them to the project.  (I know you can probably get away with adding less, but let’s keep it simple.)

• Build the project to see if it works.  (Mine worked.  Hopefully yours did too.)

• In order to run the Selenium RC test, you first have to have the Selenium RC server running.  The Selenium RC server folder should be in the files you unzipped.  Normally, I have a batch file on my desktop created to run the Selenium Server, but for our purposes, we’ll just run this from the “Start -> Run” commandline, using this command:

java -jar C:\selenium-remote-control-1.0.1\selenium-server-1.0.1\selenium-server.jar

• You should see some a dos window popup, and you will see something like the screenshot below.  DON’T CLOSE IT WHILE TESTING; IT NEEDS TO STAY RUNNING.  If you don’t have Java installed, this won’t work.  But most people should already have Java.

Next you need to select Debug from your Visual Studio menu and select “Start Without Debugging”. (I’m choosing this option because it doesn’t close the console window after the end of execution.  The debug option does.)

You should see the Selenium window(s) pop-up.  And it should do it’s thing.  When it’s finished, you should see something like this:

So, where is my test executable?  Well, it’s in the bin\debug folder of the project.  For me, the path to it looks like this:

C:\Documents and Settings\dbrown\My Documents\Visual Studio 2008\Projects\TestingBlogSeleniumTest\TestingBlogSeleniumTest\bin\Debug\

So, what do I need to run the program?  Just take the executable file and the dll’s.  Make sure the dll’s are in the same folder as the test when you execute it, otherwise you will get a big fat error.  If you send the executable to someone, make sure you send the dll’s too.

Remember if you port that executable to another computer, it needs to be a Windows box with the .NET framework installed and Selenium server needs to be running.  I hope this actually helps someone.  I’m going to post some tricks to “sex up” your console app.  Be looking for them shortly.

Sorry, I still haven’t figured out Selenium GRID good enough to post on it.  Maybe Marisa could post on it?  She’s awesome like that.

As of today, I am officially a contributor to FitNesse. I contributed a new feature idea and its implementation (the initial idea was borrowed from FitLibrary’s SequenceFixture but morphed a bit based on suggestions from Bob Martin), and also worked on Slim version detection. I am not a developer by training nor trade, but armed with basic coding skills and fueled by the guidance and what I can only describe as the graciousness of Uncle Bob, I was successful. The experience was trying, exciting, and actually pretty fun. While I learned an awful lot more than I’m going to detail here, I think I had three really important realizations while working on the updates.

TDD Works!

Given that I am a tester, I have read/learned about, discussed, and even advocated TDD. Given that I do not (usually) write production code, I had never actually tried it. I decided I’d give it a go since I needed to write unit tests for my updates anyway.

The existing unit tests for the class I updated served as my guide. I wrote a test to verify the simplest case of the new feature. I ran it – here’s the interesting thing: it passed. This surprised me, but also informed me that I did not need to make any changes to the code for the simplest case. The update involved implementing a special character to invoke a different processing scheme for function calls in Slim Script tables, so I had figured that I’d at least need to update the code to ignore the special character in the simplest case…but as the unit test proved, I did not.

I wrote a second unit test to verify another simple (yet different) case – this one failed as expected. I added code to the class in question, ran the test, and saw it fail again. But aha – I also saw why it failed, and that information helped me find my mistake. At this point I’d like to say that I made the fix, ran the test, and saw it pass – but it didn’t happen that way. I went through a few iterations of running the test and fixing my code.

The test finally passed, and I ran the entire suite of tests for the class. They all passed. The most appropriate word I can find to describe that moment is epiphanic. It was then that I truly understood and appreciated two of the benefits of TDD I have often heard:

1. Practicing TDD can help ensure that only necessary code is implemented, since the goal of writing/updating the code is to make one test pass. Remember, I didn’t even need to write any code to make the first test pass.
2. Having a suite of unit tests – a byproduct of practicing TDD – can provide confidence that updates have not unintentionally changed existing behavior. The bonus is that unit tests are fast, so the feedback can be almost instantaneous. For example, the entire suite of 208 unit tests for the class I updated runs in under 1.5 seconds on my machine.

Having an understanding of a practice is one thing; having experience implementing the practice is another. Upon reflection, I now find it odd that I could have advocated TDD without having tried it myself.

Refactoring is more than just “Changing”

I’m a bit embarrassed to admit this, but up until recently, I used the word “refactoring” as a substitute for “changing,” since I thought that’s what refactoring meant. I thought it was just a dev-ified word for “changing” or “improving.”

Once I submitted the first update to Bob Martin, I asked him for feedback. I was quite proud that the new feature took only about a dozen new and updated lines of code, but I wondered what I could have done better. Uncle Bob told me that since I had added a couple lines of code to an existing function, the function’s length was getting to the point where he’d want to extract some of the functionality – he suggested extracting a particular loop to a “method object.” I immediately Googled “extract to method object” and found information about it on refactoring.com. I quickly realized that refactoring actually encompasses specific techniques that address specific scenarios – refactoring is not just changing code.

I’m not as embarrassed to admit that I really had no clue how to execute “extract to method object.” I ruminated about it for a few days, and finally just told Uncle Bob that I didn’t know how to get started. He sent me the code, explained step-by-step how he got to the end result, but still allowed me to commit the change myself…which leads me to my last point.

I think I know one reason why he’s called “Uncle” Bob

There were many times throughout the last few weeks that I wondered when Uncle Bob would say to me “I’ll just do it myself – it’ll be faster that way.” That certainly would have been a true statement. Being that I am not – as I stated before – a developer by training or trade, I was surprised that he even supported the idea of me actually committing code changes when I first contacted him to suggest the new feature. It turns out that my fear and surprise were completely unfounded. Uncle Bob continually offered guidance and encouragement, and always ended his messages with “Let me know if you need any help.” Here’s the kicker: he meant it, too.

I really did feel like I was the lucky recipient of mentoring by a person who has literally “written the book” (multiple books, actually) about software craftsmanship.

I hope that some FitNesse users find the new feature valuable, and that I will be able to contribute to FitNesse again in the future. It was a great experience.