Man, That’s A Sweet Castle!

For those of you still with me, the last we talked I had recorded a test, and I was preparing to run it.  Then I hit you with a bunch of references and stuff.  Here’s what I ended up with after some cutting and pasting (my Basic C# Selenium Unit Test).

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Selenium;
 
namespace SeleniumTesting
{
    ///
    /// Summary description for UnitTest1
    ///
    [TestClass]
    public class InitialSeleniumTest
    {
        public InitialSeleniumTest()
        {
            //
            // TODO: Add constructor logic here
            //
        }
 
        private TestContext testContextInstance;
        private ISelenium selenium;
        private StringBuilder verificationErrors;
 
        ///
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }
 
        #region Additional test attributes
        //
        // You can use the following additional attributes as you write your tests:
        //
        // Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext) { }
 
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup() { }
 
        // Use TestInitialize to run code before running each test
        [TestInitialize()]
        public void MyTestInitialize() {
            selenium = new DefaultSelenium("localhost", 4444, "*iehta", "http://www.google.com/");
            selenium.Start();
            verificationErrors = new StringBuilder();
        }
 
        // Use TestCleanup to run code after each test has run
        [TestCleanup()]
        public void MyTestCleanup() {
            try
            {
                selenium.Stop();
            }
            catch (Exception ex)
            {
                //ignore errors
            }
            Assert.AreEqual("", verificationErrors.ToString());
        }
        #endregion
 
        [TestMethod]
        public void TestMethod()
        {
            // Open Google search engine.
            selenium.Open("http://www.google.com/");
 
            // Assert Title of page.
            Assert.AreEqual("Google", selenium.GetTitle());
 
            // Provide search term as "Selenium OpenQA"
            selenium.Type("q", "Selenium OpenQA");
 
            // Read the keyed search term and assert it.
            Assert.AreEqual("Selenium OpenQA", selenium.GetValue("q"));
 
            // Click on Search button.
            selenium.Click("btnG");
 
            // Wait for page to load.
            selenium.WaitForPageToLoad("5000");
 
            // Assert that "www.openqa.org" is available in search results.
            Assert.IsTrue(selenium.IsTextPresent("www.openqa.org"));
 
            // Assert that page title is - "Selenium OpenQA - Google Search"
            Assert.AreEqual("Selenium OpenQA - Google Search",
                         selenium.GetTitle());
        }
    }
}

Okay, notice a couple of differences between that one (the one I recorded) and the one I started out with. Note that I am not doing the same thing. I downloaded the later test from Selenium, and use that one because it has more variety in commands, and I was trying to learn the language a little bit too. Also notice the third parameter to the DefaultSelenium constructor:

//old
selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://www.google.com/");
 
//new
selenium = new DefaultSelenium("localhost", 4444, "*iehta", "http://www.google.com/");

That’s the money-maker for me. I need to test in Microsoft Internet Explorer. It’s nice to be able to test in Firefox, but IE7 is the target browser for our customers. The third parameter is what sets the browser Selenium will try to load when you run the test. Okay, now look at that first parameter. That’s just the machine you’re trying to get to (not to be confused with the URI you’re trying to get to – fourth parameter). You would have probably figured that out, but you don’t have to.

My script didn’t do anything.  I ran the Unit Test and it failed.  Remember that line, “java -jar selenium-server.jar”.  It turns out, you have to run that before you start the unit test.  That command loads the server and opens up listening on the 4444 port (or whichever port you specify).  Once I started the server and ran the Unit test again, I noticed the test succeeded (with the notable exception that I had to change some of the asserts – the Google return content had changed since that particular unit test was available for download).

That’s good stuff.  I had a running server, I ran the test, got a success notification.  Now I had a baseline test to see if I had my server set up correctly.  The test was insufficient, though.  I had an entire testing architecture in my head, and part of that was for the Selenium server to be on a server machine.  The reason for this was because our production-quality code had to use client certificates.  No matter how good a product is, once certificates get involved, things get interesting.  Selenium, it turns out, does not support X.509 certificates.  That’s not a problem.  Situations like that are exactly why Microsoft invented compilation constants (that’s a joke – don’t kill me).  In the appropriate mode, I can display a list of users to select from, or allow a tester to login as whatever role they want, through the user interface.  Consequently, if I want to test other than end-production-quality code, I’ve got to have a place to put it.  If I leave it on my machine, then my testers can’t get to it, and that creates a lot more work for me, as opposed to helping either me or them out at all.

I’ll fill you in on how that went next time.  I did learn some more interesting stuff.

This page contains a list of Selenium-related stuff I found important enough to record.  You can skip this one if you want to.

1. The Selenium Server has two parts, a server, and a client library.  That reminds me, all of the client libraries are version 1.0.1, with no intention of updating any time soon.
2. Download Selenium RC. If you want to follow with what I did, you’ll want to do this.
3. Extract to c:\Selenium.  This should give you the following subdirectories:  selenium-dotnet-client-driver-1.0.1/, selenium-java-client-driver-1.0.1/, selenium-perl-client-driver-1.0.1/, selenium-php-client-driver-1.0.1/, selenium-python-client-driver-1.0.1/, selenium-ruby-client-driver-1.0.1/, selenium-server-1.0.3/.  In the ‘selenium-dotnet-client-driver-1.0.1/’ folder, you should see: ThoughtWorks.Selenium.Core.dll, and ThoughtWorks.Selenium.UnitTests.dll.
4. Detailed installation instructions (the ones I followed) are at: http://seleniumhq.org/docs/05-selenium-rc.html.
5. The command I used to start the server was: java -jar selenium-server.jar.  You can also double-click if you have java associated with .jar files.
6. Selenium does *not* have to run on N-Unit.  The framework can be run from any C# (started narrowing down) application.
7. .NET Client Configuration on: http://seleniumhq.org/docs/appendix_installing_dotnet_driver_client.html#configuring-selenium-rc-net-reference.

I had discovered that Selenium met my requirements for ease of use (so testers can record and automate test scripts).  I also determined that, because Selenium IDE allowed saving recorded tests as NUnit C# Unit Tests, I might be able to go one step further, and use the tests which the …testers… make my developer testing more comprehensive.  Using Selenium RC, I thought I might be able to have an end-to-end automated testing solution for the application layer of our application for little more than the time necessary to research it.  It was time to see what I needed, and to download the pieces.

The first thing I needed to do was get the Selenium IDE.  Fortunately, I love FireFox, and I happened to have the very latest version on my work laptop, even though most of our development work targets IE 7.  I upgraded to 3.6.8 prior to installing my Selenium IDE, just to be on the safe side.  This had the unfortunate side effect of disabling my IETab, but I could always reinstall that once a new version comes out.  Downloading the appropriate stuff was easy.  Everything I needed was available from the SeleniumHQ Downloads page.  I downloaded and installed the FireFox Plugin with no problems.  I started Selenium IDE, to see what it was capable of (Tools->Selenium IDE).  I was presented with the IDE:

The Selenium IDE Firefox Window

My goal was to make sure that what was advertised about the product was true.  To get my end-to-end automated testing environment, I needed to:

1. Record an automated test.
2. Export the test as C# Unit Test.
3. Load the test into a C# Unit Test project.
4. Run the test.

Those are the broad strokes.  So the first thing I did was go to Google.  I typed in “http://www.google.com”, and did a search for ‘test’.  I clicked on a random link (University of Maryland – Testudo).  Then I checked out the options under the File menu.  At first, I made the mistake of performing a ‘Save As…’, which didn’t give me any option to save as C#.  I tried again, but this time saw the ‘Export…’ option, and I was able to export the test as C#.

using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using NUnit.Framework;
using Selenium;
 
namespace SeleniumTests
{
	[TestFixture]
	public class ExportedTest
	{
		private ISelenium selenium;
		private StringBuilder verificationErrors;
 
		[SetUp]
		public void SetupTest()
		{
			selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://www.google.com/");
			selenium.Start();
			verificationErrors = new StringBuilder();
		}
 
		[TearDown]
		public void TeardownTest()
		{
			try
			{
				selenium.Stop();
			}
			catch (Exception)
			{
				// Ignore errors if unable to close the browser
			}
			Assert.AreEqual("", verificationErrors.ToString());
		}
 
		[Test]
		public void TheExportedTest()
		{
			selenium.Open("/");
			selenium.Click("//span[@id='main']/div[5]/div/table/tbody/tr[1]/td/table/tbody/tr/td");
			selenium.Type("q", "testudo");
			selenium.Click("link=University of Maryland | Testudo | Schedule of Classes");
		}
	}
}

That was the extent of what I needed to prove, almost. I needed to demonstrate that it worked with the .NET Unit Test Framework. That meant I had to do some code editing. I made the following chages:
[TestFixture]->[TestClass]
[SetUp]->[TestInitialize]
[TearDown]->[TestCleanup]
[Test]->[TestMethod]
Once those were done, I had only to add the Microsoft.VisualStudio.TestTools.UnitTesting ‘using’ directive, and it compiled nicely. With that much under my belt, I was ready to actually try to run it.