Matthew M. Osborn

1 year, 12 months, 52 weeks, 365 days

Matthew M. Osborn — Sun, 07 Jun 2009 10:02:15 GMT

Somewhere around a year and half ago I decided that I need a change of pace in my life. I applied to Microsoft thinking that there was no harm in trying and got an interview. A little over a year ago I packed up two suite cases with some clothes, packed up my house, and got on a plane to Seattle. It honestly doesn’t seem that long ago that it all happened, but the following Monday morning there I was in NEO (new employee orientation).

Through my year at Microsoft I have grown leaps and bounds both technically and personally. Let’s take a look back on what I have been able to do with this year. Well the biggest thing was simply learning how to do my job. Prior to joining I had little to no experience with QA. I don’t claim to be an expert but I feel I know what I am doing now. I started off working on ASP.NET 4 and have had the opportunity to work on the web forms feature crew (anything and everything to do with web forms). This includes the new ClientID abilities, Routing, and some SEO features. Along with working on our product I have also been busy helping to improve The Lightweight Test Automation Framework that our team uses for some of it’s testing. This also includes making a public release on the asp.net codeplex.com site. Another exciting venture that I have started in my year is starting up an ASP.NET QA related podcast, Coding QA. Coding QA is a podcast that I produce with Federico where we ramble on about everything QA related.

Now on to the good stuff, the lessons learned, and let me say some of these lesson were hard learned! First, I have learned that to deliver a successful product members of a team must be aware of that team. By this I mean that everyone should be focused on their work but they should also look out for other team members. This could be as simple as walking over and asking someone if they could use any help when they are stressed. Basically, make sure you keep the machine well oiled. I think the biggest and best lesson that I have learned is one of our PUMs favorite things to say “Come to me with solutions not problems.” This is a simple saying but I think that it really sums up several key points. First, don’t waste time medaling on what is wrong but on what you can do to make it better. Second, in life no one is going to help you, you need to be willing to help yourself. I know some of these are pretty deep and cheesy but like I said I have also grown personally.

Not all of my time has been spent hard at work, I have been able to have some fun along the way. I have been able to take advantage of the perks of working for a big company (company picnic and the company meeting where Rainn Wilson hosted). Also Microsoft, sent me to Tech·Ed EMEA which was in Barcelona, Spain! I have also been able to meet some many new and interesting people.

When I left to come up to Seattle lots of people warning me about the “honeymoon phase.” Meaning that while I would love the job at first, I would get bored and wore out with it shortly after. I am very pleased to say “I TOLD YOU SO,” a year later and I still love waking up every morning and going to work. Here is too many more years to come! I’d also like to say thank you to everyone that has helped me along the way. A very special thanks go out to my family who have been extremely supportive of me even though I am thousands of miles away!

Coding QA Podcast Launched!

Matthew M. Osborn — Wed, 06 May 2009 07:20:35 GMT

It is my pleasure to announce to you the official launch of the Coding QA Podcast. Federico and I have been working on this for several months and have already released four shows with a fifth waiting to be edited. Coding QA is a weekly show about testing from the trenches. Federico and I are members of the ASP.NET QA team, and in this podcast we share our views about everything that has to do with testing and our experience of being the front line testers of a web platform. This is just one of several ways the QA team is engaging with our customers and we have received positive feedback. So please, visit the site, tune in, and let us know what you think.

ASP.NET QA Podcast – Episode 4

Matthew M. Osborn — Mon, 13 Apr 2009 21:56:29 GMT

Download : Episode 4

In the fourth installment of the ASP.NET QA Podcast Federico and Matthew discuss “The Good,” “The Bad,” and “The Ugly” of the history of the ASP.NET QA Team. Discussion ranges from the dark ages, to the renaissance, to the industrial revolution, to the “21st and half century”. Join them as they discuss the lessons learned and how the team has improved over time.

The team released the April update to the Lightweight Test Automation Framework.
“The Dark Ages” ASP.NET 1.0/2.0
- During this time the team was very focused on automating everything.
- (disadvantage) This approach is not good with a changing Spec.
- (disadvantage) Bugs were being found to late in the process.
- (advantage) Excellent automation coverage.
“The Renaissance” Atlas/Microsoft Ajax
- The division moved to a feature crew model for development and QA.
- (advantage) The team adopted a heavy unit testing practice. Increase in code coverage.
- (disadvantage) The QA team still worked has it had before. It would automate everything is less time.
“The Industrial Revolution” ASP.NET 3.5
- The QA team began to adopt the Feature crew model and started the process of agile testing with exploratory testing.
- (advantage) Bugs were being found at the beginning of the process.
- (disadvantage) The team still wrote a large amount of automation.
“21st and half century” ASP.NET 3.5 SP1/ASP.NET 4.0/vNext
- The team has really started moving away from automating everything and is spending more time investigating user scenarios.
- The team has formed its own unique blend of agile, scrum, and any other buzz word project management theory.
- (advantage) Creating and automating sample applications provides feedback for real world customer scenarios.
- (disadvantage) The team is young and is still learning the best practices.
- (Struggle) Costing has become less of a clear cut process.
- (Struggle) The is still a barrier between the QA and Dev teams.
- (Struggle) No one wants the blame when a bug is found.

Links from the show :

Lightweight Test Automation Framework April Release

Matthew M. Osborn — Thu, 09 Apr 2009 19:10:50 GMT

The April release of the Lightweight Test Automation Framework for ASP.NET has just been posted and you can download it here. For this release, the team has worked hard to include the following bug fixes and new features. Please continue to give us your feedback as many of the fixes and features are based what we have heard from the community.

Improvements to the user interface

A new look has been given to the test name when it passes or fails. There is both color and visual queues that indicate weather a test has passed or failed. Failed test names also appear slightly larger to help them stand out.
There is now a “Run Failed Tests” button. This button will open a new browser window that will select and run only the failed tests, for easy verification of fixes.

The ability to automate popup windows

In previous versions of the framework there was no way to verify the contents of a popup window. With this release we have far better support for opening and verifying the contents of popup windows.

HtmlPage page = new HtmlPage("MyPage.aspx");
page.Elements.Find("OpenPopup").Click();
// get popup window
HtmlPage popup = page.GetPopupWindow(1);
// verify title of popup
Assert.AreEqual("This is the Popup Page", popup.Elements.Find("h1", 0).GetInnerText());

The GetPopupWindow method returns a HtmlPage object that is representative of the window at that index. This is pulled from the collection that is maintained by the framework with index zero being the main, or starting, window. In this example index zero is MyPage.aspx, while index one is the popup window.

The ability to find elements by partial attribute values

In previous versions of the framework when finding elements on a page you could only use the ID attribute to match against. So if you wanted to match all the elements that had a CSS class applied to them, as is common in jQuery, you had to supply that whole value for the class attribute. So, in previous versions of the framework if you wanted to find elements that had a CSS class applied to them you had to specify the whole value for the class attribute. Meaning that if the element has more than only class and you search based on only one class that element would not be returned. Now you have the ability to match based on any part of the value for the attribute. Below is an example of how to find elements that have the CSS Class “blue” applied to them.

HtmlElementFindParams find = new HtmlElementFindParams();
find.Attributes.Add("class", "blue", MatchMethod.Contains);
ReadOnlyCollection<HtmlElement> elements = page.Elements.FindAll(find);

Assembly name change

The assembly name has been changed from “Microsoft.Web.Testing.Light” to “Microsoft.Web.Testing.Lightweight.” The namespaces have not changed.

Podcast Playlist

Matthew M. Osborn — Wed, 08 Apr 2009 06:22:00 GMT

Each day my commute takes anywhere from 45 minutes to 1 hour depending on the traffic and if I ride the bus. About a year ago, I decided to make the most of the stop and go traffic and start listening to podcasts in hopes that I might learn a thing or two. Most people at work know that I am an avid podcast listener and always ask me for my favorites, so I figured I would compile a list of my top tech/geek podcasts.

Rating *	Name	Type
	.NET Rocks	Code/Interview
	Alt.NET	Code
	Behind the Code	Code/Interview
	StackOverFlow	Code
	Boagworld	Web Design
	Channel 9	Code/Interview
	Channel 10	Interview/Misc
	Elegant Code	Code
	Google Developer Podcast	Code
	Hanselminutes	Code/Interview
	Herding Code	Code
	Pixel8	Code/Interview
	Ruby on Rails Podcast	Code
	System	Hardware/Geek
	The Rissington Podcast	Web Design
	This Week in Tech (twit)	Geek
	Pixel Perfect	Photoshop
	Coding QA Podcast	Code/QA

* Based on the frequency I listien to them and overall content

ASP.NET QA Podcast – Episode 3

Matthew M. Osborn — Tue, 31 Mar 2009 23:08:59 GMT

Download : Episode 3

In the third installment of the ASP.NET QA Podcast Federico and Matthew interview Mark Berryman, a test lead on the ASP.NET QA Team. Join them as they learn the ins and outs of test management through Mark’s eyes.

Release of the Mobile Browser Database by Live Dublin.
April refresh of the Lightweight Test Automation Framework.
Interview with Mark Berryman.
- What is the difference between Test Manager and Test Lead.
- A little history of Mark and how he came to join the ASP.NET QA team.
- Responsibilities of a Test Lead / What Mark is working on.
- What Mark looks for in a tester on his team.
- Challenges Mark faced when he was an IC (individual Contributor).
- What Mark would change on items he has tested in the past.
- How Mark Manages risk on his team.
- Who is Marks favorite person in the whole world.

Links from the show :

ASP.NET QA Podcast – Episode 2

Matthew M. Osborn — Fri, 20 Mar 2009 18:52:26 GMT

In the second installment of the ASP.NET QA Podcast Federico and Matthew discuss MIX 09 announcements and the ins and outs of supporting various browser versions on the ASP.NET QA team.

MIX 09 Conference announcements
- MVC RTM 1.0
- Silverlight 3.0
- Web Application Installer
- Web Application Gallery
What browsers the team tests on and how they decided which browsers to test.
What it means when the team says they support a browser.
How the team manages the risk of not testing on every possible browser.
The timeline for testing features on multiple browsers.
The infrastructure the team has to test on multiple browsers.
How the team keeps up with the fast growing browser market, such as the release of four major browsers in just a few months.

Links from the show :

Download : Episode 2

ASP.NET QA Podcast – Episode 1

Matthew M. Osborn — Thu, 12 Mar 2009 04:53:21 GMT

In the first ever ASP.NET QA Podcast Federico and Matthew discuss the motivation behind the community involvement from the QA team and the release of the QA team’s Lightweight Test Automation Framework for ASP.NET and what it is.

Introductions to the podcasters, Federico and Matthew.
What is it that the ASP.NET QA team does.
The recent release of ASP.NET MVC RC2.
The recent release of the source code to the Lightweight Test Automation Framework.
The purpose of the release of the framework to codeplex.com and where it fits in the market.
Why the QA team chose to write their own automation framework.

Links from the show :

Disclaimer : This is our first try at creating, editing, and publishing a podcast. Please bear with us as we iron out all the wrinkles in the process. Your feedback is greatly appreciated.

Download : Episode 1

Lightweight Test Automation Framework Source Released!

Matthew M. Osborn — Thu, 12 Feb 2009 02:01:23 GMT

The Asp.NET QA team has been working to make what we do and our processes more visible to our customers. Two major things we have done to increase this are, releasing the Lightweight Test Automation Framework binaries with a sample to Codeplex.com and starting our ASP.NET QA Blog. Well, over the last week we reached another milestone by releasing the source to the Lightweight Test Automation Framework on Codeplex.com. This is the first time we have tried to do something like this on the ASP.NET QA team and we are very excited. Visit Codeplex.com and check it out for yourself!

Items Updated in the February Update of the Lightweight Test Automation Framework include

Thanks go out to all those who have helped to get this release out the door, with a special thanks to the lead developer Federico Silva Armas.

ASP.NET 4.0 ClientID Overview

Matthew M. Osborn — Wed, 07 Jan 2009 01:41:10 GMT

Introduction

One of the new features being added to version 4.0 of ASP.NET is the ability to control the client side IDs that are generated by the framework. Previously the framework would modify the client side IDs to uniquely identify each control. This some times left you with the ID you defined in markup or sometimes left you with something that looks like this, “ctl00_MasterPageBody_ctl01_Textbox1.”

The Problem

The modification of the client side id property works great to ensure that each element is uniquely identified, however, to anyone that has tried to do any sort of client side scripting this becomes very frustrating. Chances are that if you have worked in ASP.NET for any time at all you have run into this issue. The problem is that until runtime you do not what the client side ID could be, making it difficult to do any kind of client side scripting. In addition any modification of the page, adding removing controls, can result in a different client side ID being generated.

Old Solution

Again if you have worked with ASP.NET for any amount of time you know there is a work around for this issue. Each control has a property called ClientID that is a read only and supplies the unique client side ID. You can use this in a code behind when dynamically adding scripts, or more commonly use inline code (old ASP style) to supply the value to and client side scripts.

<script type="text/javascript">
    function DoSomething(){
        alert('<%= Control.ClientID %>');
    }
</script>

ASP.NET 4.0 Solution

First off let me start by explaining why we decided to tackle this problem in version 4.0 of the framework. While we provided a way of supplying the developer with the client side ID, with the growth of client side scripting this solution has become some what hacky. There is not really a clean way to use this with lots of controls and lots of external script files. Also it might have had something to do with the developer asking for control over this. Developers do love to have control of everything, weather they use it or not, it’s just our nature :) The solution that we came up has four ‘modes’ that a user can use giving them everything from existing behavior to full control. The controls ID property is modified according to the ClientIDMode mode and then used as the client side id.

Modes and what they do

There is now a new property on every control (this includes pages and master pages as they inherit from control) called ClientIDMode that is used to select the behavior of the client side ID.

<asp:Label ID="Label1" runat="server" ClientIDMode="[Mode Type]" />

The Mode Types

Legacy: The default value if ClientIDMode is not set anywhere in the control hierarchy. This causes client side IDs to behave the way they did in version 2.0 (3.0 and 3.5 did not change this code path) of the framework. This mode will generate an ID similar to “ctl00_MasterPageBody_ctl01_Textbox1.”
Inherit: This is the default behavior for every control. This looks to the controls parent to get its value for ClientIDMode. You do not need to set this on every control as it is the default, this is used only when the ClientIDMode has been changed and the new desired behavior is to inherit from the controls parent.
Static: This mode does exactly what you think it would, it makes the client side ID static. Meaning that what you put for the ID is what will be used for the client side ID. Warning, this means that if a static ClientIDMode is used in a repeating control the developer is responsible for ensuring client side ID uniqueness.
Predictable: This mode is used when the framework needs to ensure uniqueness but it needs to be done so in a predictable way. The most common use for this mode is on databound controls. The framework will traverse the control hierarchy prefixing the supplied ID with it’s parent control ID until it reaches a control in the hierarchy whose ClientIDMode is defined as static. In the event that the control is placed inside a databound control a suffix with a value that identifies that instance will also be added to the supplied ID. The ClientIDRowSuffix property is used to control the value that will be used as a suffix (see samples). This mode will generate an ID similar to “Gridview1_Label1_0”

Samples

Legacy Mode

Legacy mode is pretty straight forward, it generates a client side ID the way that it had in version 2.0 of the framework.

markup:

<asp :TextBox ID ="txtEcho" runat ="server" Width ="65%" ClientIDMode ="Legacy" />

output:

<input id="ctl00_MasterPageBody_ctl00_txtEcho" style="width: 65%" name="ctl00$MasterPageBody$ctl00$txtEcho" />

Static Mode

Static is the most basic of all ClientIDMode modes, what you give for the ID is what you get for the client side ID. Once again a warning that if a static ClientIDMode is used inside of a repeated control it is the developer’s responsibility to ensure client side ID uniqueness.

markup:

<asp:TextBox ID="txtEcho2" runat="server" Width="65%" ClientIDMode="Static" />

output:

<input id="txtEcho2" style="width: 65%" name="ctl00$MasterPageBody$ctl00$txtEcho2" />

Predictable Mode

Predictable mode really tackles the heart of the problem. The framework previously generated it’s unique IDs to prevent ID collisions and the most common place for these types of collisions are inside databound controls. Predictable mode is really designed to work with databound controls but does not have to. There is three ways to uses the predictable mode, each one of these is defined through the ClientIDRowSuffix property that specifies the suffix for each instance. The ClientIDRowSuffix uses values from the control’s datakeys collection, so if the control does not have a datakeys collection this property is not viable. If this property is not set or is not available the row index will be used in it’s place.

1. With no ClientIDRowSuffix defined, this is also the behavior for databound controls without a datakeys collection e.g. Repeater Control. Notice that the framework has traversed the control hierarchy and prefixed the ID with the parent’s ID and suffixed the ID with row index.

markup:

<asp:GridView ID="EmployeesNoSuffix" runat="server" AutoGenerateColumns="false" ClientIDMode="Predictable" >
    <Columns>
        <asp:TemplateField HeaderText="ID">
            <ItemTemplate>
                <asp:Label ID="EmployeeID" runat="server" Text='<%# Eval("ID") %>' />
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Name">
            <ItemTemplate>
                <asp:Label ID="EmployeeName" runat="server" Text='<%# Eval("Name") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

output:

<table id="EmployeesNoSuffix" style="border-collapse: collapse" cellspacing="0" rules="all" border="1">
    <tbody>
        <tr>
            <th scope="col">ID</th>
            <th scope="col">Name</th>
        </tr>
        <tr>
            <td><span id="EmployeesNoSuffix_EmployeeID_0">1</span></td>
            <td><span id="EmployeesNoSuffix_EmployeeName_0">EmployeeName1</span></td>
        </tr>
        ...
        <tr>
            <td><span id="EmployeesNoSuffix_EmployeeID_8">9</span></td>
            <td><span id="EmployeesNoSuffix_EmployeeName_8">EmployeeName9</span></td>
        </tr>
    </tbody>
</table>

2. With a ClientIDRowSuffix defined, this looks in the control’s datakeys collection for the value and then suffixes the ID with that value.

markup:

<asp:GridView ID="EmployeesSuffix" runat="server" AutoGenerateColumns="false" ClientIDMode="Predictable" ClientIDRowSuffix="ID" >
    <Columns>
        <asp:TemplateField HeaderText="ID">
            <ItemTemplate>
                <asp:Label ID="EmployeeID" runat="server" Text='<%# Eval("ID") %>' />
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Name">
            <ItemTemplate>
                <asp:Label ID="EmployeeName" runat="server" Text='<%# Eval("Name") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

output:

<table id="EmployeesSuffix" style="border-collapse: collapse" cellspacing="0" rules="all" border="1">
    <tbody>
        <tr>
            <th scope="col">ID</th>
            <th scope="col">Name</th>
        </tr>
        <tr>
            <td><span id="EmployeesSuffix_EmployeeID_1">1</span></td>
            <td><span id="EmployeesSuffix_EmployeeName_1">EmployeeName1</span></td>
        </tr>
        ...
        <tr>
            <td><span id="EmployeesSuffix_EmployeeID_9">9</span></td>
            <td><span id="EmployeesSuffix_EmployeeName_9">EmployeeName9</span></td>
        </tr>
    </tbody>
</table>

3. With a ClientIDRowSuffix defined, but instead of just one value a compound value will be used. Exhibits the same behavior as one value but it will suffix both values onto the ID.

markup:

<asp:GridView ID="EmployeesCompSuffix" runat="server" AutoGenerateColumns="false" ClientIDMode="Predictable" ClientIDRowSuffix="ID, Name" >
    <Columns>
        <asp:TemplateField HeaderText="ID">
            <ItemTemplate>
                <asp:Label ID="EmployeeID" runat="server" Text='<%# Eval("ID") %>' />
            </ItemTemplate>
        </asp:TemplateField>
        <asp:TemplateField HeaderText="Name">
            <ItemTemplate>
                <asp:Label ID="EmployeeName" runat="server" Text='<%# Eval("Name") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

output:

<table id="EmployeesCompSuffix" style="border-collapse: collapse" cellspacing="0" rules="all" border="1">
    <tbody>
        <tr>
            <th scope="col">ID</th>
            <th scope="col">Name</th>
        </tr>
        <tr>
            <td><span id="EmployeesCompSuffix_EmployeeID_1_EmployeeName1">1</span></td>
            <td><span id="EmployeesCompSuffix_EmployeeName_1_EmployeeName1">EmployeeName1</span></td>
        </tr>
        ...
        <tr>
            <td><span id="EmployeesCompSuffix_EmployeeID_9_EmployeeName9">9</span></td>
            <td><span id="EmployeesCompSuffix_EmployeeName_9_EmployeeName9">EmployeeName9</span></td>
        </tr>
    </tbody>
</table>

Summary

The ability to fully control the client side IDs that are generated by the framework is a request that has not generated much noise but everyone seems to want it when you mention it. We believe that we have found a good solution to the request and think that it adds some much need functionality for developer that use lots of client side scripting. There is an early preview and a walk through of this feature in CTP build that we released at PDC 2008. For more information and a much more detailed description of this feature read Scott Galloway’s blog post.