Sample Code & Slides from StarEast 2013 Talk

I gave a talk on Four Tips for Web Automation at StarEast 2013 this April. I’ve posted up my slides on SpeakerDeck

You can also find the demo code at my GitHub repository.

I’ll be doing a similar talk at StirTrek this Friday!

Slides From Quest 2013 Posted

Thanks to the folks who attended my talk at Quest 2013! I appreciated the interaction, and I hope you found the talk useful.

You can find my slides, and the mind map, here on SpeakerDeck.

Exciting News: I’m Now an MVP for ALM!

I just got news today that Microsoft has changed my Most Valuable Professional award from C# to Application Lifecycle Management (ALM). This is great news for me because this is much more in my wheelhouse both technically and passion-wise. Moving to ALM means I’ll be much more inline with things I work on regularly and care intensely about: testing, process, and making teams awesome.

I’m also very excited because I get to hang out with a bunch of awesome ALM geniuses like Esteban Garcia, Ryan Cromwell, and others. This is going to be awesome!

Oh, you thought my last post meant I wasn’t an MVP at all anymore? Oh, terribly sorry for that, but I figure there had to be something evil I could do on April Fool’s Day…

I’m No Longer a Microsoft MVP for C#

Yes, I realize it’s April Fools Day; however, this isn’t a joke. After a wonderful string of years, I got notification from Microsoft that I’m no longer an MVP for Visual C#. Frankly, I’d figured this was coming some time ago and I’m surprised it took this long.

Why? Because I don’t code for a living, and I don’t focus on C#. I don’t know anything about C# 4.0, contravariance, or covariance. Ask me to write a lambda, or explain how it differs from a delegate, and you’ll likely see my head explode or me head for the nearest bottle of scotch. I was put into the C# category in 2005 because they didn’t have a better spot to put me for all the community work that I was being recognized for, and it’s always been awkward for me.

My award wasn’t so much due to specific things I’ve done as it was due to all the awesome folks in the community, and I want to make sure to thank all the wonderful people who made the last seven or eight years great. Well, I can’t thank all y’all by name, but I hope you get the idea…

My time as a C# MVP has been awesome. I’ve gotten some wonderful opportunities, and I’ve met some amazing folks.

And by the way, no, I’m not going to go on an anti-MVP rant about how the program leeches off everyone and makes MVPs lose their morals and self-worth. The MVP program is what individuals make of it. I got a tremendous amount out of it, and again, thanks to everyone for their support over the years.

Nor am I going to give up .NET and go to Ruby. Duh.

Despite this news I’m sure cool things will come along, so please don’t get your undies in a wad over my case. I’m good with it. It’s been a great experience.

I’m No Longer the Evangelist for Test Studio

It’s true. I’ve been asked to give up my dream job that I’ve loved working for the last 20 or so months.

Instead, I’m now the Director of Engineering for Test Studio and am going to help with delivery of the automation tool I love so much.

Yes, I know. That was a bad trick to play. You’ve been reading my blog and haven’t figured this part of my “humor” yet?

In the new role I’ll be working closely with the teams in Austin and Sofia on planning and execution for future releases. It’s a scary but wonderfully exciting opportunity, and truth be told I had been missing being part of actively building software.

I’m not vanishing from the testing community—that involvement is a critical part of better understanding problems that we can help solve with Test Studio—but the amount and shape of my involvement will change as I move my focus to the teams at Test Studio.

One thing this brings up in a big way: Telerik needs another Evangelist to fill my position. We’re already looking for one, so this means we’ve got a second slot to fill, too!

Want to know more? Have a look at the job description and drop me a line to chat me up!

Cleaning Up Windows 2008 OS Drive

I try to keep the virtual machines I use for development, demos, and testing fairly lean. I use a smallish C: partition (60GB or so) and force everything to install to a second D: drive. All my projects and data end up on D:. This has saved me several times in the past when I’ve needed to rebuild a crashed VM—just reinstall the OS and off you go. I also like to think that it helps performance, even on a VM, by keeping IO off the operating system drive. No, I’ve never bothered to actually measure performance for this. Why do you ask?

Today I ran into a rather interesting set of problems when trying to run code coverage metrics in Visual Studio 2012. Of course my tester homies all this this is epically funny and cool.

A quick bit of troubleshooting found the following, uh, minor problem:

WinDirStat is the next tool to jump on, and it quickly shows where the problem lies. The winsxs folder, where backup copies of every DLL dating back to Windows 3.01 are stored. OK, so it’s not quite that bad, but every time anything’s impacted by Windows Update or a Service Pack then cruft gets thrown in there.

Disk Cleanup is a handy utility to clean out unneeded backups of these, plus lots of other goo; however, it’s not installed by default on a Windows 2008 server OS. You’ll need to go add the Desktop Experience Feature (Server Manager | Features | Add Feature | Desktop Experience), then Disk Cleanup will be available under Start | Accessories | System Tools.

I ran Disk Cleanup and got back a huge chunk of disk real estate – Disk Cleanup also let me know I had an extraordinary amount of temp file usage, too. And here I thought I’d been doing better regular maintenance on my server…

Next maybe I should go check the last time I changed the oil in the car.

 

(PS: Turns out this didn’t fix the epic crashes, but it was still needed. Hopefully it’s useful to you.)

Learning JustMock for Working with Nasty Dependencies

Update: I totally forgot to give mad props to colleague and good pal Phil Japikse for walking me through a couple things over IM in the course if noodling all this out.

I’ve given my Unit Testing 101 talk ten or 20 times over the last four or five years and I love it. I enjoy getting folks introduced to unit testing without having to deal with dogma issues around Test Driven Development, Test Occasionally Development, etc.

Part of the talk hits up working with mocking in order to get past a dependency on external providers. The example I use is a security provider used to check whether or not the current user’s authorized to update info for an employee.

In the past I’ve used Rhino.Mocks to work through this. I’ve used Rhino in a few projects over the years and it’s been a great tool for me.

Being the rather dense guy I am, I forgot that the awesome company I work for has its own mocking tool: JustMock. I figured it made sense to alter my tests to work with JustMock, if for no other reason than I could speak halfway intelligently to questions on it from other folks I interact with in the community.

One of the things I was most interested in was dealing with badly handled dependencies in code. The example I used previously had a nice constructor-injected interface-based security provider, so it was easy and clean to handle with Rhino. Here’s how it looks:

public class EmployeeUpdater

{

    private readonly IUpdateEmployeePermissible _updateEmployeeSecurityProvider;

    public EmployeeUpdater(

        IUpdateEmployeePermissible updateEmployeeSecurityProvider)

    {

        _updateEmployeeSecurityProvider = updateEmployeeSecurityProvider;

    }

    public Employee UpdateEmployeeRate(Employee targetEmployee, float newRate)

    {

        Employee updatedEmployee;

        if (_updateEmployeeSecurityProvider.

            CanUpdateEmployeeRate(targetEmployee.EmployeeId))

        //if (true)

        {

            updatedEmployee = new Employee(

                targetEmployee.EmployeeId, 

                targetEmployee.FirstName,

                targetEmployee.LastName,

                targetEmployee.Address, newRate);

        }

        else

        {

            throw new SecurityException(

                "Invoking user doesn't have permissions to update target target employee. " +

                                        targetEmployee);

        }

        return updatedEmployee;

    }

}

A test using Rhino, complete with interaction verification, is straightforward:

[Test]

public void Verify_security_provider_is_called()

{

    int userId = 1;

    int oldRate = 5;

    int newRate = 10;

    var mockProvider = MockRepository.GenerateMock<IUpdateEmployeePermissible>();

    mockProvider.Expect(x => x.CanUpdateEmployeeRate(userId)).Return(true);

    Employee current = new Employee(userId, "Jim", "Holmes", "Doghouse", oldRate);

    EmployeeUpdater updater = new EmployeeUpdater(mockProvider);

    Employee updated = updater.UpdateEmployeeRate(current, newRate);

    mockProvider.VerifyAllExpectations();

}

I took and muddied up the EmployeeUpdater a bit to mimic code we’ve either written ourselves or have seen: “new”ing up objects instead of injecting them, and using calls to static methods or classes. These situations make it tough to mock things out and will force you to move to a commercial mocking tool like TypeMock or JustMock. [1] (JustMock has an extremely powerful free version, but mocking concrete classes, “future mocks” of items “new”ed up instead of injected, or static requires the commercial version.)

Here’s my uglified EmployeeUpdater class. I simply created two different methods, one which newed up the security provider in it, another which hit the provider via a static call.

public class EmployeeUpdaterLegacyStyle

{

    public Employee UpdateEmployeeRate_ProviderNewedUpHere(Employee targetEmployee, float newRate)

    {

        UpdateEmployeeSecurityProvider _updateEmployeeSecurityProvider =

            new UpdateEmployeeSecurityProvider();

        Employee updatedEmployee;

        if (_updateEmployeeSecurityProvider.

        CanUpdateEmployeeRate(targetEmployee.EmployeeId))

        //if (true)

        {

            updatedEmployee = new Employee(targetEmployee.EmployeeId,

                targetEmployee.FirstName,

                targetEmployee.LastName,

                targetEmployee.Address, newRate);

        }

        else

        {

            throw new SecurityException(

                                        "Invoking user doesn't have permissions to update target target employee. " +

                                        targetEmployee);

        }

        return updatedEmployee;

    }

    public Employee UpdateEmployeeRate_ProviderIsStaticHere(Employee targetEmployee, float newRate)

    {

        Employee updatedEmployee;

        if (UpdateEmployeeSecurityProvider_Static.CanUpdateEmployeeRate(targetEmployee.EmployeeId))

        //if (true)

        {

            updatedEmployee = new Employee(targetEmployee.EmployeeId,

                targetEmployee.FirstName,

                targetEmployee.LastName,

                targetEmployee.Address, newRate);

        }

        else

        {

            throw new SecurityException(

                                 "Invoking user doesn't have permissions to update target target employee. " +

                                        targetEmployee);

        }

        return updatedEmployee;

    }

}

JustMock handles both quite nicely. First, working with “future” mocking to handle the variant that instantiates the object in the method. Note I’m working with a concrete class. No interfaces, no virtual, just a straight concrete class that’s instantiated right in my method above. The final mockedProvider.Assert() validates the security provider’s method was indeed called by the updater. (Comment out the //if(true) portion in the updater to see that test fail!)

public void Mocking_provider_newed_in_method()

{

    int userId = 1;

    int oldRate = 5;

    int newRate = 10;

    var mockedProvider =

        Mock.Create<UpdateEmployeeSecurityProvider>();

    //Standard syntax for mocking

    //Mock.Arrange(() => 

    //    mockedProvider.CanUpdateEmployeeRate(userId))

    //        .IgnoreInstance()

    //        .Returns(true)

    //        .Occurs(1);

    //using the fluent interface from JustMock.Helpers 

    mockedProvider.Arrange(x => x.CanUpdateEmployeeRate(userId))

                  .IgnoreInstance()

                  .Returns(true)

                  .Occurs(1);

    Employee current =

        new Employee(userId, "Jim", "Holmes", "Doghouse", oldRate);

    EmployeeUpdaterLegacyStyle legacyUpdater =

        new EmployeeUpdaterLegacyStyle();

    Employee updated = 

        legacyUpdater.UpdateEmployeeRate_ProviderNewedUpHere(current, newRate);

    Assert.AreEqual(updated.HourlyRate, newRate);

    //Standard assert

    Mock.Assert(mockedProvider);

    //Fluent from Helpers

    mockedProvider.Assert();

}

Here’s a test handling the static call variant above:

[Test]

public void Mocking_provider_called_statically()

{

    int userId = 1;

    int oldRate = 5;

    int newRate = 10;

    Mock.SetupStatic(typeof(UpdateEmployeeSecurityProvider_Static),

        StaticConstructor.Mocked);

    bool called = false;

    Mock.Arrange(() => 

        UpdateEmployeeSecurityProvider_Static.CanUpdateEmployeeRate(userId))

        .Returns(true)

        .Occurs(1);

    Employee current =

        new Employee(userId, "Jim", "Holmes", "Doghouse", oldRate);

    EmployeeUpdaterLegacyStyle legacyUpdater =

        new EmployeeUpdaterLegacyStyle();

    Employee updated = 

        legacyUpdater.UpdateEmployeeRate_ProviderIsStaticHere(current, newRate);

    Assert.AreEqual(updated.HourlyRate, newRate);

    Mock.Assert(() => 

        UpdateEmployeeSecurityProvider_Static.CanUpdateEmployeeRate(userId),

        Occurs.Exactly(1));

}

I’m sure there are better ways to leverage JustMock, and I’m sure there are cleaner ways to write the test. This exercise was more about me learning what capabilities JustMock has so I could keep it somewhat clear in my own head.

I’d love to hear feedback from folks who’ve worked with both mocking tools! Have you worked with Rhino.Mocks and JustMock? Have any thoughts?

[1]Perhaps Rhino.Mocks now handles these situations. I fully admit I haven’t kept up with it…

CodeMash Financial Planning Sheet

UPDATED

Interested in more detail on how we plan CodeMash? Want to see all the gory (and scary!) financial figures behind the scenes?

We’ve posted up the exact Excel sheet I use to plan everything financial around CodeMash. If you’re a conference organizer, or considering organizing one, then this sheet may be of great use to you. Yes, it’s tailored to CodeMash, but it’s full of information that may be very useful to you. There are a number of things it helps me with every year:

• Meal planning: I’m able to keep track of the various meals, plus I have some notes around what I need to make sure gets covered. (Think proteins for vegetarians, greens at each meal, etc.)
  • Fixed versus consumable costs: Planning conferences starts off as “We’ll get awesome sessions and have fantastic people!” and inevitably turns to “Crap. How am I going to organize and pay for all this food?” If you’re organizing a conference you absolutely have to keep a careful eye on your food costs. I break out fixed costs (per head things like meals and party food) versus consumable (variable) costs like soda, coffee, and drinks. Those consumable costs terrify me because the impact can be thousands of dollars.
• AV costs: Tracking Kalahari and external vendor AV costs helps me ensure I’ve got the right count of projectors, microphones, and screens ordered to cover every day.
• Attendee gifts: I use this as a checklist to help ensure I’ve got shirts/hoodies, USB sticks, etc. ordered up.
• Psuedo-TODO List: All the items on the various tabs serve to remind me of some of the various things we have to ensure get covered.

The workbook isn’t perfect. I refactor it every year based on things I’ve learned (usually the hard way). Just this year I finally deleted out columns I’d had hidden which contained revenue and estimated expenses for attendee headcounts of 250, 400, 500, and 700. It’s been a few years since we were that small…

Still, it’s invaluable for me in planning. It may be of interest to you, and it follows CodeMash’s policy of being as transparent as possible around our finances.

Grab it here! I hope you find it useful and informative!

UPDATE: I didn’t make clear that this workbook is not finalized for 2013. Consumables (soda, coffee, cocktails and beer) always are a huge variable, and there are always a bunch of last minute charges/changes. That $31K surplus will be nowhere near that by the time things are said and done.