Mattias Sköld

Microsoft Test Manager Preview (MTM11)

2011-09-26T22:29:00.002+02:00

About 18 months ago Microsoft’s released Microsoft Test Manager (MTM), a new test tool with focus on agile teams and collaboration. MTM introduced a lot of features to simplify and improve common test tasks and improve team collaboration. A week ago, at the build conference Microsoft release a Preview of the next version of Visual Studio including MTM.

Missing feature set in MTM2010
Even if MTM brought many new features to the tester, MTM do have some short comings and lack some features most testers expects. Amongst the most commonly wanted is the possibility to use Multi Line and Rich Text Formatting in Test Steps. The edit test case experience only uses a fraction of the screen to edit/view test steps. Testers have found workarounds for some issues like editing in excel and pasting back to MTM or using third party tools like the Test steps editor (http://teststepeditor.codeplex.com). Of course the list of wanted features is a lot longer, but I think those mentioned is amongst the most commonly wanted.

MTM11 addresses most commonly wanted features
The big story in MTM11 is focused around Exploratory testing , but a quick look at the preview of MTM11 it looks like Microsoft also focus on addressing the the wanted features in the next release. MTM11 now supports Multi Line, and Rich Text Formatting (even if the formatting toolbar is pretty limited). Even the test case editor is improved and a splitter is introduced so you can adjust and use all available space for viewing /editing test steps.

MTM11 Backward compatibility?
With the most commonly asked for features fixed I was curious, is MTM11 backward compatible with TFS 2010 and MTM 2010? Could I be using the MTM11 on a TFS 2010 project side by side with MTM2010 and use the new features?
After taking a test drive I found that Microsoft seems to have backward compatibility on its mind. MTM11 works directly an existing tfs2010 team project. I can view/edit/run test cases with both MTM11 and MTM2010. Using MTM11 against an old TFS2010 team project gives me a better test case editor with Multi Line editing. If I open a test case created in MTM2010 and adds line breaks in test steps they render correctly in MTM2010
However, using MTM11 against an old team project disables the rich text editing is however disabled. To enable the rich text editing you need to connect to a tfs11 project or probably do some kind of process template upgrade.

Test step editor and MTM/TFS 11?
As many teams already worked around the limitations of MTM with tools like test steps editor, I was also curious how the next generation of TFS and MTM11 react to test cases edited with the test steps editor. The questions are, does MTM11 acknowledge line breaks made by test steps editor and how will they be treated by TFS11? From my test drive it looks promising, MTM11 seems to handle line breaks made by test steps editor in an old TFS2010 team projects. Upgrading the project to TFS11 works fine, and the line breaks made by test steps editor works fine in MTM11 after the upgrade.

MTM11 Preview is a good start
This post is just based on my findings after a short test drive with a preview of the next generation of MTM, but it looks promising. If Microsoft makes MTM11 backward compatible it will make it a lot easier to implement and use the version of MTM in real life projects. Hopefully Microsoft will continue and address commonly requested features like real pause/resume of test cases (new status), edit test cases during execution, ability to bind data bound test cases against SQL commands or other data sources.

TFS Reporting

2011-08-09T02:05:00.007+02:00

If you want to do reporting against TFS there are three different data sources to consider. In this post I’ll go briefly through the possible data sources and there usage, pros and cons.

TFS Relational Warehouse
The TFS relational warehouse is an SQL database dedicated for reporting data inside TFS. The TFS Warehouse has a public schema and is the supported place to do SQL reporting against the TFS Data. The information in TFS Warehouse is an extract from the production data and is updated on interval (by default 2 h)

TFS Cube
The TFS cube is an analysis database storing aggregated information from the TFS warehouse. The TFS Cube is most suited for reporting on trends and aggregated info. Reporting tools are primary Excel for AdHoc reporting and SSRS using MDX as the query language. For those not too comfortable with the MDX language there is a tool on codeplex (http://olappivottableextend.codeplex.com) that allows you to use excel to create the query and then lets you show extract the MDX query.

TFS Production data
If you want access to all details of the TFS implementation, without the time delay you need to go directly against the TFS production data. The only supported way to do so is by using the TFS API. The downside is that you need to develop and deploy a solution wrapping the TFS API and consume it in your report.

Summary
For most cases the TFS Warehouse is your first choice, unless you want to do reporting on trends or aggregated information the TFS Cube is probably your first choice . If you can’t do with the (small) time delay or need access to RitchTextFields or other values not present in the TFS warehouse, you will need to develop and deploy your own data source using the TFS API.

TFS OData Services as data source for SSRS reports

2011-05-05T00:07:00.006+02:00

In April Microsoft release a beta of TFS OData Services , enabling a simply way to query and update tfs using http Url’s and atom xml data f, even from non-Windows platforms. This is good news for everyone who wants to extend tfs to mobile devices, but I saw an alternative use for it.

Looking for a SSRS data source
If you want to create reports containing details of work item, a story card report for example, you don’t really have a good data source to base your report on. The TFS Warehouse doesn’t offer vital fields like description, history and many other fields of importance. So far the best option I’ve found is to use Ewald Hofman’s solution in this post http://www.ewaldhofman.nl/post/Work-item-query-as-input-for-a-RS-report.aspx. Although it’s a proven working solution it requires both customizations and deployment of a web services . If TFS OData services will be a part of TFS installation it could be the answer I’ve been looking for.

Installing TFS OData services
To test the new TFS OData services, I started installing it on one of our lab servers. Quite quickly it became obvious that TFS OData install is not install that simply installs the TFS OData Services on a Server. It installs a complete development environment for developers who wants to build mobile TFS applications. To get it installed I switch to a lab devbox and installed all the tools required by the install. Once installed I needed to point the TFS OData services to a tfs server, this was no problem. One thing that caused me some problems was to handle the certificates.

OData as datasource in SSRS
As Microsoft has been pushing OData quite a bit, I was expecting it to be fairly easy to consume OData services in SSRS. Sadly I was surprised to find out that SSRS can generate an OData feed, but have no guidance how to consume OData as a data sources. After quite some time searching and asking around my colleagues I found a solution. SSRS have an XML data source, and you can specify an url as connection string. You can also specify Query parameters and how to translate the returning xml using the Query in SSRS. The following XML translates the OData response to fields in SSRS:

<Query>
    <ElementPath IgnoreNamespaces="true">
        feed{}/entry{}/content{}/properties
    </ElementPath>
</Query>

OData & SSRS - Possible but not practical
So it is possible to consume OData services in SSRS, but it’s not really practical as you specify the URL in the data source. OData uses the URL as the query specification, forcing you to have one data source for each query you intend to use. It might be possible to fix this or write an custom data source adapter for OData, using SSRS extension model.

Beta 1 shortcomings
As I got a data source and a query in SSRS, I started to create a simple story card report. Quite soon I run into trouble. Some parts of the URI’s used for accessing queries is less natural, like /ColletionName/Queries('b3844370-e517-471d-a55c-d45f9bf7716d')/WorkItems This formats with guids as identifiers for queries, instead of query name, might work if coding against it, but for manually doing reporting it’s not a great experience.
The next problem is that the beta 1 of TFS OData returns a predefined subset of a work item, regardless of the work item definition, or the query specification. This is a show stopper, at least as a SSRS data source.

Conclusion
If you want to create reports containing details of work item the best option is still Ewald Hofman’s solution to create an web service to execute Work Item Queries using the TFS API. TFS OData has to develop and grow a bit before it can be used as a data source, on the other hand it’s only a beta 1 yet. The potential is there in the OData format and if its developed and delivered as a part of TFS it could be used as a standardized data source for TFS data.

How to change iteration for Burn Down reports in project portal

2011-03-13T23:47:00.009+01:00

Last week I needed to change the default iteration for the burn down chart in the (WSS) team project portal . My first thought was that this should be a simple task done in minutes, as the burn down chart is a SSRS report and I know I can change the default parameters for SSRS reports on the properties tab of the SSRS report.

How to change default parameters for SSRS reports
The simplest way to change the default parameter for a SSRS report is to right click on the Reports folder in team explorer and select Show Report Site. Once the report site opens up in your browser, click on the report you want to change, and then the report shows, click on the Properties tab. In the left border, click on the Parameters tab. Now you can see all parameters in the report and change their default values. Some of them are easy to change, others like the iteration parameter is not expressed in a intuitive or user friendly format.

Finding the right iteration expression
To find the value for an iteration, you need read access to the TFS Cube, and a tool such as SQL Server Management Studio. To get the desired iteration value you have to browse the TFS Cube, find and browse the Iteration hierarchy, find the desired iteration and drag it over to the query area. This procedure is described in detail in a post by John Socha-Leialoha (http://blogs.socha.com/2009/10/customizing-report-parameters-for-team.html)

In my case, and I suspect in many other cases, I didn't have read access to the customers tfs cube, forcing me to find another way to get the iteration value. In other cases, access and knowledge to tools could be a show stopper.

An easier way
As I was forced to find another solution, I came up with the idea to create a custom SSRS report showing the iterations and their corresponding iteration values/expression. Creating the report was easy, and all I had to do once created was to upload it to the server and set the data source. Once done, I simply run the report, find the iteration I need and I can copy the iteration value at the same row. Next time I need to change the iteration, I simply run the report again.
I think it is a really simple and good way to solve the problem, so if you running iterations and want to change the current iteration every 2-4 weeks, grab the report from my skydrive http://cid-5d46cae8c0008cf0.office.live.com/self.aspx/.Public/AreasAndIterations.rdl

TFS Scorecard 2010 Beta 1 released on CodePlex

2011-02-19T18:18:00.006+01:00

Today I released a beta of TFS Scorecard for TFS 2010 at CodePlex http://TfsScorecard.codeplex.com. Since the release of TFS2010 I've been working on an adopting the TFS Scorecard to the schema changes of TFS2010 data warehouse and cube. Upgrading to the TFS 2010 schema changes was not a big deal and soon fixed. But the old version was dependent on extensions to the tfs cube.

Old version bad install experience
The TFS2008 version was dependent on extensions made to the schema of the TFS Cube for the adoption queries. This made the install procedure all but smooth and simple. To solve this problem I did a TFS Warehouse adapter making the schema changes, but it still was
an extra step to follow and I would personally think twice myself before adding an external third party data warehouse adapter to a production server.

No more extensions to the cube.
Then I started to look at how to upgrade or adopt the cube extensions, I wanted to improve the install experience, or at least not make it worse. After some thoughts I got the idea to skip the cube extensions and do SQL queries against the TFS Warehouse instead. As the TFS Warehouse contains all data used by the cube schema extensions, I could solve the problems with SQL without requiring any changes by the user. Using SQL against the warehouse instead of MDX agianst the cube could of course hurt performance, but I don't think this is a big concern as the Scorecard report is probably scheduled or viewed once a week in most cases.

Manual Test metrics
With the new test tools for manual testing (Microsoft Test Manage ) I thought it would be nice to get a picture of the adoption of manual testing with MTM. So I made an Manual Test metrics in the adoption page.

Beta release- please provide feedback
I think there is some work left to do on the TFS Scorecard report. I didn't take any time to fix the small details of the report graphics. You could always discuss and improve metrics and other features. Download and try the TFS Scorecard 2010 release from codeplex and if you have any ideas, comments or feedback in general I would be pleased if you let me know.

Back in business

2011-02-05T17:45:00.001+01:00

This week was the first real work week for a while. For the last eight month I've been on parent leave taking care of my daughter at home. During my parental leave I've been taking a couple of smaller customer assignments. Somehow they ended up being more than a couple, leaving no time for this blog amongst other things.

But this week I'm back in business, My daughter started at the local daycare center and I went back to work. Hopefully this will mean that I can do some post on the stuff I've done during the parental leave. I also started to work on my backlog, hopefully it will result in some posts and announcements.

About announcements, this week I got an email from Microsoft congratulating me to the Microsoft Community Contributor Award. It's always nice with all kinds of feedback, all comments, emails and even awards :) are greatly appreciated and motivates me to share my thoughts, findings and experience.

TFS2010 Automated team project creation

2010-10-14T14:28:00.005+02:00

This is a update on a the code from a previous post TFS Admin, Part II - POC Automated Order process. It has been upgraded to handle tfs2010 and different team project collections .

The feature set includes
• Order form for team project.
• Approval of team project orders
• Automatic team project creation
• Assigning of admin permissions to project admin.
• Reassigning work items to project admin
• Assigning contributors (New)
• Applying standard enterprise access rights
• Applying standard policies
• Sending notification email to project admin

Future plans
I'm in progress of implementing post creation synchronization of contributors. At the moment you can add contributors by editing the contributors field in the SharePoint list. The tool then synchronizes (add) the user as contributor to TFS, RS & WSS. So far the tool doesn't remove contributors or synchronize the list of contributors in SharePoint with the team project. The goal is to make it possible to handle the most common tfs user administrative tasks directly in the SharePoint portal, without installing any client side tools.

Code, Binaries and SharePoint list template
You can find the source, binaries and a SharePoint list template at my skidrive http://cid-5d46cae8c0008cf0.office.live.com/self.aspx/.Public/TFS2010%20Automated%20Team%20Project%20Creation.zip. The process of implementing is described in the TFS Admin, Part II - POC Automated Order process post. The process is most about about creating a custom list in sharepoint and edit the tools config file.

Main TFS server upgrade

2010-09-06T09:30:00.001+02:00

During the weekend my colleges and I upgraded our main tfs server with 150+ users to tfs2010. We started to plan this upgrade in April, and overall it has been a smooth and easy upgrade. But of course it always turns up things you didn't expect then you started planning. This post contains our unexpected findings, and how we solved them.

The plan
First a short description of our plan. In order to minimize the risk and minimize disruptions, we choose a migration upgrade. Choosing a migration upgrades allows us to have an good and easy rollback plan but even more important, we can do several real life rehearsals.
Our plan covered three rehearsal upgrades. The first rehearsal is just error pruning, go for a upgrade and see what problems you detected. We also start documenting , creating scripts and time every step.
The second rehearsal main objective is to verify your fixes. It is also a good way to test and make final adjustments to your own documented install process. A third run is a good idea, just to prove that everything works without any surprises. After a run without unexpected surprises you are ready to do the upgrade

SharePoint 2010
Our original plan was to move to SharePoint 2010 during the migration. During the first test run it came clear that the heave use of Conchangos Scrum for Team System template in combination with the lack of support and problem to get even the latest SfTS template to work with SharePoint 2010 was a showstopper.Back to wss3 until SfTS supports SharePoint2010

New reports missing permissions
During the migration a reports are created at /TfsReports/DefaultCollection/TeamProject . It turned out that the permissions is not migrated, leaving it inaccessible for team members. Needing to fix this 100+ folders we made a short program to copy the permissions from the old report folders to the new 2010 report folders. You can find the program and the source at my skydrive http://cid-5d46cae8c0008cf0.office.live.com/browse.aspx/.Public/SyncRsRoles.

Conchangos Scrum for Team System wss templates.
It is a well know fact that the SfTS 2.2 template and TFS2010 upgrades represents a big problem, good news is that EMC has released plans to make a WorkItem Migrator, at least a step in the right direction. Never the less, we didn't anticipate to have so much trouble getting SharePoint template for SfTS project portals in place. Without it all project portals and document libraries for project based on the SfTS template is inaccessible, SharePoint simply returning http error 404.
Our solution was to do a simply filecopy of the folder C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\SiteTemplates\SCRUM, from the older server to the same location on the new server.

The new buildreport not working
The jury is still out on this one. The new build report gives us the following error.

File system error: The record ID is incorrect. Physical file: \\?\D:\OLAPDATA\Data\Tfs_Analysis.0.db\Dim Build Platform.0.dim\5.BuildPlatformName.(All).ostore. Logical file: .

We have spent several hours rebuilding the cube and warehouse without any success. I will post an update when we have solved this issue.

Walkthrough: How to import Word test cases to MTM

2010-08-10T23:48:00.037+02:00

Lately I been getting lots of hits on my posts about the extended Test case migrator tool, and even some questions on how to use it. This post is a quick walkthrough to show how to use the tool to import test cases in word documents to Microsoft Test Manager.

Before we start
The first thing you need to do is to get the extended test case migrator tool running. Please refer to my previous postsTool for import word test case documents to Microsoft Test Manager and http://mskold.blogspot.com/2010/06/updates-to-my-extensions-of-testcase.html. You can download either the compiled exe or the complete soure code and compile it yourself.

Getting started
The first you need to do is verify that your test case documents can be parsed by the extended test case migrator (TCM). The extension I made for TCM is intended to import test cases written for humans. It relies on that your document is formatted using font styles or colors. The simplest way to verify if your document can be parsed is simply to try to parse it using the tool.

#1 Select your source
After starting and clicking Next in the welcome screen the first real step is to select your data source. In order to import word test cases select the Word TestCase document (table format) and enter or select the path to a folder containing your word test cases.

#2 Select your target team project
The next step is to select your target team project. You also need to select the Work Item Type representing a Test Case.

#3 Create a new settings file
The third step is to simply create a new settings file. You can also load a previous saved settings file.

#4 Fields listing
The next step is to modify the list of detected fields. The tools scans a document for labels and captions and presents a list of them. If you miss any field you can add and you can them and the tool will check if it can find it. If your list is empty or doesnt contain any of the fields you expected your document layout can't be processed by the current version of the tool.

You can also delete unwanted fields from the list to make it simpler to handle in the coming steps. When you click next all documents are scanned to verify that the fields can be found in every document. This can take a while if you have many documents, for example 100 documents takes 10-20 minutes (or more) to scan depending on your computer.

#5 Map your fields against TFS fields
Now it's time to map your "word" fields against the fields in the tfs test case work item. The Test Step Title and Test Step Expected Result is treated special and the tool will iterate through all values and create test steps.

#6 Map values against TFS values
For fields who has defined value lists in TFS you will be prompted to map your word value against the valid TFS values. In this example I mapped the TFS Area fields against the RequirementReference word field in the previous step. This will allows me to map the text values in word to an Area path in TFS.

#7 Save settings
Before you start importing you can save your settings to a file and change the default location of the log file.

#8 Confirm
Simply click Save and Migrate to start the import. As most of the work is done in earlier steps the import process is rather quick.

#9 Verify outcome
After the import is completed you will hopefully se a screen similar to this. You may also receive warnings and errors for part of the import. If you do, click the View output log file link and try to figure out what documents has problems and what to do to it.

Updates to my extensions of the TestCase Migrator Tool

2010-06-08T23:55:00.003+02:00

As described in my earlier post I made some extensions to the Test Case Migration Tool, http://tcmimport.codeplex.com/ so it can handle importing old test cases in word documents to Microsoft Test Manager. Recently I have tested to import 100+ test cases with a slightly different template. Of course its always something that can be done better so I've updated my extensions to be more tolerant to differences in templates.

You can find the latest bits http://cid-5d46cae8c0008cf0.office.live.com/self.aspx/.Public/TestCaseMigratorExtendedExe.zip
You can also find the source at http://cid-5d46cae8c0008cf0.office.live.com/self.aspx/.Public/TestCaseMigratorExtendedSource.zip

Last changed Team projects - Custom Report for tfs 2008

2010-05-29T00:58:00.002+02:00

As a TFS admin I sometime wonder how many team projects is in use and maybe when it was last changed. Sometimes I've been forced to find out and I have created some SQL queries to run against the warehouse to figure it out.

Packaged into an custom SSRS Report
Now I have packaged those queries into a custom SSRS report for tfs2008. You download the report at my skydrive http://cid-5d46cae8c0008cf0.skydrive.live.com/self.aspx/.Public/TeamProjectLastChanged.rdl Once downloaded you simply needs to upload it to your own TFS Server and point the data source to the tfs standard TFSReportDs shared data source.

TFS2010 updated version http://cid-5d46cae8c0008cf0.office.live.com/self.aspx/.Public/TeamProjectLastChanged2010.rdl

TFS with WSS 3 to SharePoint Foundation 2010 upgrade

2010-05-17T00:20:00.005+02:00

During the weekend we successfully upgraded a production server from TFS2010Beta2/WSS3 to TFS 2010 RTM/SharePoint Foundation2010 RTM. The new challenge in this, apart from the usual upgrade of a production server, was to include upgrading WSS3 to SharePoint Foundation 2010.

Migration scenario
In this case we went for the Server Migration/upgrade scenario, which is very good if you need to verify and test our upgrade routines. This was very important as we to include the move from WSS to SharePoint Foundation 2010 in the upgrade and the WSS upgrade procedure hasn't made it into the official installation documentation yet, so we had to find the right way before we went for the big move.

Don't forget the InstanceId
If you migrate your server to a new hardware for testing purposes, or simply keeps the original server on the network, you have to change the instanceid of your server. Buck Hodges has a post on this, including information on how to change instanceid in TFS 2010. http://blogs.msdn.com/buckh/archive/2006/10/17/creating-a-new-server-from-an-old-one-beware-of-the-instanceid.aspx

Installation of SharePoint Foundation 2010
This was really simple, once I got the install of SharePoint Foundation 2010 right. Sadly to say it took me several tries getting a new unwanted separate SQL instance for SharePoint. If you want to use your existing SQL instance you have to select Server Farm installation and then Complete Server Farm. IF you select that path, you can point out your existing SQL Server instance during configuration.

Upgrade from WSS to SharePoint Foundation 2010
Searching for information how to upgrade tfs & wss to SPF 2010 I found this posts http://sharepointgeorge.com/2009/upgrading-content-database-sharepoint-2010-database-attach-method/
During verification of content db it prompted for two non blocking missing components, as expected, as I had not configured TFS and it SharePoint extensions yet.
Attaching the content db using stsadm -o addcontentdb -url -databasename resulted in an attached and upgraded content database up and running according to the Managed content databases pages in SharePoint Central Administration. Browsing to team project portals did howevere not work at this stage.

After configuring TFS and upgrading the team project collection witch installs the TFS add-ons to SharePoint, browsing to the project portals worked fine as far as we could se.

The upgrade process in short steps
Install Server roles according to TFS installation
Install SQL Server according to TFS installation
Install SQL Server SP1 Cumulative update package 2, KB 970315 (http://support.microsoft.com/kb/970315)
Restore Reporting Services

Stop Reporting services
Restore backup,
Start
Restore encryption keys
Remove Orginal server from scale out deployment
Verify

Install SharePoint Foundation 2010 PreReq
Restart
Install SharePoint Foundation

Select Server Farm,
Select Complete
Configure
Create New Farm
Use existing SQL server

Install Team Foundation Server
Import wss3 content database

Verify using SharePoint 2010 Management Shell and run Test-SPContentDatabase –Name -WebApplication
2 Missing components
Attach database stsadm -o addcontentdb -url -databasename

Configure TFS
Upgrade team project collection
Update Instance Id

iisreset /stop
tfsconfig changeserverid /sqlinstance: /databasename:Tfs_Configuration
tfsconfig registerdb /sqlinstance: /databaseName:Tfs_Configuration
iisreset /start
net start tfsjobagent

Sogeti TMAP process template certified and ready

2010-04-21T21:29:00.013+02:00

Today we finalized the RTM version of our TMAP process template and it will soon be available for free download from the official TMAP.Net site there you also can find more information about the TMAP process and the latest news from the testing field. You can also go directly to the download page located at http://eng.tmap.net/Home/archief/957794.jsp.

Certified process template
Sogeti's TMAP template has as the first template passed the new Visual Studio Certified Process Templates Program announced by Microsoft and can therefore use the new Certified process template logo. If you want to know more about the certification program Stephanie Saad Cuthbertson has a post on the details.

TMAP.codeplex.com
The TMAP template will continue to develop and improve on codeplex. You will still find the latest bits and contribute on the future directions of the TMAP process template by filing feedback and suggestions at tmap.codeplex.com.

Upgrading TFS 2010 RTM from pre-release versions

2010-04-21T00:21:00.000+02:00

Today I upgraded one of our internal pre-release server and moved in to a new machine. What before in the old days with TFS2008 could be a real painful experience taking several hours or even days to perform could now mostly be handled in an hour.

Preparations
This post is simply a brief description of the main steps and what to do and expect. If you want a more detailed information and as preparation always is the key to success I recommend you to read the following

Microsoft Team Foundation 2010 Install guide
VS ALM Rangers TFS 2010 Upgrade guide at codeplex
Bryan Krigers post on TFS 2010 Upgrade
SSW's Rules To Better TFS 2010 Migration

Backup and In place upgrade
The first step is to backup the current environment, be it databases or taking a snapshot of your existing environment. Once that's done Its time to uninstall the previous installed pre-release versions. You can leave the .Net framework as it will be upgraded, but TFS2010 Beta2/RC must be uninstalled. After removing the Pre release versions simply install TFS2010 RTM, It's a very easy and quite fast but did take me a reboot to finish it.
Once installed its time to configure your server. If your moving from prerelease versions it's important that you select Upgrade in the first page of the configuration wizard. Follow the steps of the wizard and then you finish the upgrade you will have an upgraded Team Project Collection.

Move to new machine = Detach, Move, Attach
If you want to move to a new clean machine (without any previous installed beta software) you simply Detach your newly upgraded team project collection using Team Foundation Administrative Console. Once detached backup the database TFS_MyProjectcollectionName to file using SQL Manager.
Now it's time to move to a new fresh start. Simply Install and configure TFS2010 RTM on a clean machine. After its done, restore the previous backed up database to the new SQL Server using SQL Manager. Once installed its time to attach, simply point out the database and attach it to your server and you now have your upgraded team project collection up and running on your new server.

Tool for import word test case documents to Microsoft Test Manager

2010-04-09T22:59:00.007+02:00

Updates to my extensions of the TestCase Migrator Tool http://mskold.blogspot.com/2010/06/updates-to-my-extensions-of-testcase.html

Recently I had a case there I needed to import old test cases written in word into Microsoft Test Manager. I looked around for a tool capable of importing an ordinary test case written in word, but I didn't find any tool or solution.

Word - the world's most used test tool ?
In my experience most projects who have had formalized test cases has done them in word documents containing test case information (title of the test case, description, pre-conditions, use case identification) and test steps. The test steps has the format of a table with columns for actions and expected results.

Test Case Migration Tool on codeplex
The best match I found was the Test Case Migrator Tool on codeplex (http://tcmimport.codeplex.com). With this tool I could import Excel test cases and MTH files (Microsoft's word template for test cases from earlier versions of Microsoft Test Edition). This looked like a promising tool but when I tried it on our existing test cases written by a standard test case template the tool didn't manage to import the test cases. It seemed the tool was to hard connected to the structure of the MTH template.

Extending the Test case migration Tool
As the project was on codeplex with the source code available I did take a look to see if I could adopt the tool to our template. As the tool had a nice separation of the logic for parsing and importing data sources , I simply created a new data source and wrote my own parsing logic for our template. At first i simply replaced the MTH data source with my, but ones I got the parsing logic to work I started to integrate it as a new data source in the UI. This turned out to be a bigger task then writing the parsing logic. It took some time but at least the result looks good.

The extended Test Case Migration Tool is available
I have uploaded both the compiled version and the source with my modifications as I guess many other will find themselves in the same situation as I was - looking for a tool to batch import word test cases. Hopefully this could be a solution for some of you .

Contacting all users running non Tfs2010 compatible clients

2010-04-08T23:07:00.000+02:00

Looking at migrations of several tfs servers with 100+ users, I got the urgent need to track and inform users not already upgraded vs2008 & vs2005 with forward compatibility pack. Tracking is easy, I use the Tfs Scorecard and its activity logging features to figure out who is running vs200 RTM and SP1 clients. The problem is that I don't get a good list to paste into a mail, due to reports format and user formats.

Easier to send mail
After looking at the report a number of times and thinking " It would be good to have an send mail button" I finally did something about it. In the Tfs Scorecard clients report I added a list of user accounts and a Send Email link creating a new email with all email addresses, visible if you expand the first level.
This latest feature is now available in source control at http://tfsscorecard.codeplex.com , direct link http://tfsscorecard.codeplex.com/SourceControl/changeset/changes/46822

Swedish site about VS2010 TMAP process template

2010-03-26T08:21:00.018+01:00

Now you can read more about Sogeti's TMAP process template for Visual Studio 2010 (in Swedish). At www.sogeti.se/Test-Microsoft you can find a brief description of Microsoft test tools and Sogeti's TMAP process template.

TMAP Flyers
You can also download flyers (in Swedish) for the VS2010 TMAP and process template. There is also flyers focused only on TMAP as a method and Sogeti's other testing services.

Events about TMAP and Microsoft Test tools
You can also find information about upcoming events around Microsoft test tools and TMAP. The first event will be at Microsoft Sweden on the 23 of April. This event will be followed by several events around the country.

TMAP for VS2010 RC released

2010-03-09T19:39:00.008+01:00

Clemens just released a new version of Sogetis TMAP process template for VS2010. Ive just started to install it on our swedish 2010 pre-release server so our swedish testers can evaluate ,learn and contribute to it.

Upgrading TFS event subscriptions to 2010 SDK

2010-02-28T19:28:00.011+01:00

Some days ago I started to upgrade one of my TFS customization to the 2010 SDK. The application I moved uses WCF to host its services and automatically subscribes and consumes TFS events. It didn’t turn to be the easy, straight on upgrade I thought it should be. This is my findings during the upgrade.

Relocated TFS SDK assemblies
The first (and about the only) thing I expected was to be replace TfsServer with TfsTeamProjectCollection, and in some cases TfsConfigurationServer. Moving my solution over to a new and clean machine with only VS2010 on it, I discovered that the Tfs SDK Assemblies has moved away from its old locations. After some searching I found the new location C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0

Where did IEventService go ?
After finding the new assemblies, replaced TfsServer with TfsTeamProjectCollection I still had some compiler errors, the IEventService interface was unknown? I tried to search for any information about changes in 2010 but came up short. After some searching I found it again. It had simply moved around in the namespaces and is now located at Microsoft.TeamFoundation.Framework.Client namespace.

Windows 7 security
With all compiler errors fixed, it was time for a first test. I started the application and got direct failure. It turns out that you have to grant rights to url namespaces with
netsh http add urlact url=http://+:8001/ServiceUrl user=mydomain/mysuser
After granting rights to my user the the services starts and the application subscribes to events.

TFS2010 switched to Soap1.2
After some testing I don’t receive any incoming notifications. Following Grant holidays post TFS2010: Diagnosing Email and SOAP subscription failures (http://blogs.msdn.com/granth/archive/2009/10/28/tfs2010-diagnosing-email-and-soap-subscription-failures.aspx) shows me the following error
HTTP code 415: Cannot process the message because the content type 'application/soap+xml; charset=utf-8' was not the expected type 'text/xml; charset=utf-8'
This indicates that tfs has switch to Soap 1.2. To solve this I simply switch the bindings of my services from BasicHttpBinding till wsHttpBinding

Finaly working
The last thing it took to get the events working was to change the security mode to SecurityMode.None. So if you want to set up an WCF endpoint this code will do it, without any extra configuration files.

Uri baseaddress = new Uri("http://" + System.Environment.MachineName + ":8001");
srvHost = new ServiceHost(typeof(NotificationServiceImpl), baseaddress);

// Check to see if the service host already has a ServiceMetadataBehavior
ServiceMetadataBehavior smb = srvHost.Description.Behaviors.Find();
// If not, add one
if (smb == null)
smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
smb.MetadataExporter.PolicyVersion = PolicyVersion.Default;
srvHost.Description.Behaviors.Add(smb);
// Add MEX endpoint
srvHost.AddServiceEndpoint(
ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex"
);

srvHost.AddServiceEndpoint(typeof(INotificationService), new WSHttpBinding(SecurityMode.None ), "StructureChangeNotify");
srvHost.Open();

Complete code
Below you can find the complete code, you can also download a zip file with the solution from my skydrive http://cid-5d46cae8c0008cf0.skydrive.live.com/self.aspx/.Public/EventSubscriber2010.zip

// INotifyServices.cs
namespace EventSubscriber
{
[ServiceContract(Namespace = "http://schemas.microsoft.com/TeamFoundation/2005/06/Services/Notification/03")]
public interface INotificationService
{

[OperationContract(Action = "http://schemas.microsoft.com/TeamFoundation/2005/06/Services/Notification/03/Notify", ReplyAction="*")]
[XmlSerializerFormat(Style = OperationFormatStyle.Document)] /* Took me hours to figure this out! */
void Notify(string eventXml, string tfsIdentityXml);

}
}

//NotifyServices.cs
namespace EventSubscriber
{
public class NotificationServiceImpl : INotificationService
{
void INotificationService.Notify(string eventXml, string tfsIdentityXml)
{
MessageBox.Show(eventXml);
}
}
}

// Form.cs
using System;
using System.Windows.Forms;
using Microsoft.TeamFoundation.Framework.Client;
using Microsoft.TeamFoundation.Client;

using System.ServiceModel;
using System.ServiceModel.Description;

namespace EventSubscriber
{

public partial class Form1 : Form
{
protected ServiceHost srvHost;
protected int subscriptionId;

public Form1()
{
InitializeComponent();
}

private void cmdStartWCF_Click(object sender, EventArgs e)
{

Uri baseaddress = new Uri("http://" + System.Environment.MachineName + ":8001");
srvHost = new ServiceHost(typeof(NotificationServiceImpl), baseaddress);

// Check to see if the service host already has a ServiceMetadataBehavior
ServiceMetadataBehavior smb = srvHost.Description.Behaviors.Find();
// If not, add one
if (smb == null)
smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
smb.MetadataExporter.PolicyVersion = PolicyVersion.Default;
srvHost.Description.Behaviors.Add(smb);
// Add MEX endpoint
srvHost.AddServiceEndpoint(
ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex"
);

srvHost.AddServiceEndpoint(typeof(INotificationService), new WSHttpBinding(SecurityMode.None), "WorkItemChangedNotify");

srvHost.Open();

lblRunning.Text = "Running";

}

private void cmdStopWCF_Click(object sender, EventArgs e)
{
srvHost.Close();
lblRunning.Text = "Stoped";

}

private void cmdSubscribe_Click(object sender, EventArgs e)
{

TfsTeamProjectCollection tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(txtServerUrl.Text));
tpc.EnsureAuthenticated();

IEventService eventService = tpc.GetService(typeof(IEventService)) as IEventService;
DeliveryPreference delPref = new DeliveryPreference();
delPref.Address = "http://" + System.Environment.MachineName + ":8001/WorkItemChangedNotify";
delPref.Schedule = DeliverySchedule.Immediate;
delPref.Type = DeliveryType.Soap;

subscriptionId = eventService.SubscribeEvent(System.Environment.UserDomainName + "\\" + System.Environment.UserName, "WorkItemChangedEvent", "", delPref);
lblSubId.Text = subscriptionId.ToString();

}

private void cmdUnsubscribe_Click(object sender, EventArgs e)
{

TfsTeamProjectCollection tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(txtServerUrl.Text));

IEventService eventService = tpc.GetService(typeof(IEventService)) as IEventService;
eventService.UnsubscribeEvent(subscriptionId);
lblSubId.Text = "na";
}

}

Performance optimizing with the vs2010 profiler I

2010-01-20T09:19:00.010+01:00

Optimizing existing code for performance is one of my favorit tasks. It is a work what gives immediate measurable feedback, always learns you something new, and is in many cases easier then you think, especially if you use the new profiler in vs2010.

Setup
The first thing you need to do is find some way to test that you still deliver the same functionality. Now days this tends to be less of a problem, as many projects tends to have some kind of unit tests (although in many cases it’s more automated Integration tests) . If not it time to write some 
Other ways to accomplish this is to agree/ write some testcases

Establish a base line
Once you have a way to test that you don’t (unknowingly) change the functionality its time to find and reproduce the performance issues. It is not reproducible in a new environment, it's in most cases better to try to find the bottlenecks in the environment before you go for optimizing the code.
After reproducing the performance issues, the next step is to establish a base line. By setting a baseline before you start changing the code you have something to compare your results against. Establishing a baseline is more a procedure and some extra thoughts on how to test and measure your progress. In practical it’s the first performance report you collect from your system saved away

Creating a performance session
Now its time to get started, simply create a new performance session, As before you can choose between sampling and instrumentation.Sampling providing a quick and good enough approach and instrumenting as an more exact and complex approach. I tend to end up doing the instrumenting, although I must admit sampling really is good enough for me, I guess I like the feeling of exactly knowing what’s going on. You can read at msdn: Walkthrough: Profiling Applications

All in one profiling
A new feature in the Vs2010 profiler is that it now collects data about calls to other tires like the database. Before I was most of the time forced to use both the Profiler and SQL server profiler to collect information about database interactions and where execution times. With VS2010 I now can collect basic database interaction information directly in the VS2010 profiler, showing you the queries executed and their execution time. This information is valuable enough to point me in the right direction witch query to look deeper into, although I still can see cases there I will use the SQL Server Profiler.

Better performance reports
One other great improvement from usability perspective is the new graphical presentation of your function, both showing a graphical representation of the time spent in the function, and the code annotated with execution times! The graphical representation of the function calls is also clickable. This makes it really simple and almost joyful to navigate around in your callstack looking at the code and the execution times, giving you a quick idea about what needs and can be improved.
Colin Thomsen has writen 2 post about the new performance reports VS2010: New Profiler Summary Page and VS2010: Investigating a sample profiling report (Function Details)

A new beginign for the TFS AdminTool

2009-12-08T16:59:00.004+01:00

If I had to pick the most important tool for TFS, it would without a doubt be the TFS Admin tool. It has saved me (and many others) a lot of trouble and many, many hours. To be truly honest it has made me say some bad words to, from time to time.
This makes it extra joyful to read Ladislau’s post on the release of a CTP for the new TFS Admin 2.0 version with TFS2010 Beta2 support.

New user interface
The CTP shows of a completely new user interface. New Features includes
• bulk edit of users
• pending changes window
• output/trace window.
The most important is that the new UI seems to be more reliable than the old one.

Completely redesigned and rewritten codebase
The new user interface is not the only thing the team behind the TFS admin tool has accomplished. The TFS Admin code has gone through a major reconstruction, separating the user interface from the logic and making the code more testable. The core management of user rights is package in a separate project/assembly making it very easy to use/and extend. It is now possible to write your own gui/process and relay on the TFS admin tool to take care of the boring and time consuming tasks. Great news for the TFS community!

VSTS2010 as a modeling tool II

2009-10-15T00:18:00.011+02:00

In my last post I wrote about VSTS 2010 as a modeling tool for more abstract levels like general UML illustrations and requirements modeling. In this post I will take a look at VSTS2010 as a modeling tool for more technical modeling.

UML at the concrete level
The next step after requirements is usually to do some kind of analyzing and/or basic design as the first step towards the destination - real code. After the initial design the next step is to complete the design into a fully technical specification. Now days many projects tend to skip formal analyzing and initial design and go direct to coding. For the people who do go all the way there is/has been tools like Rational Rose/XDE, Enterprise Architect and UModel who could even go the whole way to generate code from the design.

VSTS2010 as an analyzing and initial design tool
Doing analyzing and initial design requires more of your tool than just fancy images. You need some kind of repository to share and reuse your discovered elements. VSTS2010 handles this through the UML Model Explorer. The model explorer act as an in memory repository making it possible to browse through your defined elements. You can organize your elements hierarchy in the model explorer by creating package.
In VSTS2010 you can create class, activity and sequence diagrams and drag and drop elements from the model explorer to your diagrams. Changing objects, like renaming classes or operations, updates all diagrams. It is also possible to promote object and messages to classes and operations. Basically it got most of the capabilities needed for analyzing and initial design of a system.

VSTS2010 as an advanced design first tool
When it comes to doing model first design and more advanced scenarios this first version of Microsoft’s UML modeling tools hits its limitation. The first and most important limitation for using as a complete or advanced design tool is the lack of connection to the source code. Other tools like Enterprise Architect from SparxSystems or UModel from Altova can go the whole way and synchronize (round tripping) your design model and source code.

Even if I could model everything inside VSTS it is not much use going to that kind of detail, if I can’t reuse it to create code. Putting that much effort in a design model requires the ability to generate code and sync changes in code back to the model.

The second limitation or showstopper is the lack of import export features. Especially the capability to import models or code to the model makes it harder to start using it on an existing project. You basically have to create all your elements by hand if you want to use it on an existing project. It would be really useful to have the capability to import source code to generate classes in the model.

VSTS2010 features for understanding existing code
Even if VSTS2010 lack some vital capabilities as an advanced design first model tool, it has many advanced features for architecture and design. VTST2010 focus a lot on understanding your existing code, and the architectural explorer and the architectural tools provides good value and is worth a own post. When it comes to design and UML tools VSTS2010 has a great function for generating sequence diagrams from code, and beta2 promise to be even better, providing drilldown, comments and interactivity in the sequence diagrams making it even easier to understand the existing design.

Summary and reflections
I think that the VTST2010 modeling tools can provide a value in most projects, as a general UML tool or as a tool for analyzing and initial design. If you don't have a modeling tool today, or have an advanced tool you're not using to the full extent should definitely take a look at the model capabilities of VSTS2010. One good way is to stay tuned to Cameron Skinner's blog and his coming post on modeling in VSTS2010.

VSTS2010 as a modeling tool

2009-10-06T21:07:00.021+02:00

Earlier this week I had the opportunity to take the VSTS beta out for a test drive as a modeling tool. My task was to suggest and describe possible scenarios of usage for an external vendor. Luckily I had a virtual environment with vsts2010 beta at hand (I never leave home without it :) ) So I took vsts out for a spin as my modeling tool.

Communicating at an abstract level
The task was really to communicate, at a high abstraction level, complex scenarios and interactions between the user, part of our system and part of the vendor's system. After thinking about it for a while I decided to try a sequence diagrams to illustrate the interactions. So I started creating a new sequence diagram. Doing so was quite easy and in a couple of minutes I had my first sequence ready. But drawing a sequence diagram is only usefull if you can publish it. In order to do so I simply copied and pasted the diagram into my word document.

VSTS2010 as a basic UML drawing tool
As a drawing tool for basic UML illustration I must say VSTS2010 looks really good. Of course there are always things you miss or wish for, especially in a version one beta. My biggest issue was that I wasn’t able to change the icon for the objects in the head of the lifeline. The first overall impression is that it is easy to work with and have a good feeling as a drawing tool.

VSTS2010 as a requirements modeling tool
As it felt good as a drawing tool I got curious if it could be used more as a modeling tool in a project. One of the first things in a project is in most cases modeling requirements in some way.

In VSTS2010 modeling requirements is mainly done by creating use case diagrams. Once again it is fast and easy to create a use case diagram and populate it with actors, use case and systems boundaries. In VSTS2010 you can create (or link to ) a user story work item (or any other work item). This gives you a direct link from the high level model to the detailed requirements documentation. Another feature in VSTS2010 is that you can add artifacts to your use case diagram and link them to either work items or files in general. My colleague Clemens Reijnen wrote a post on this Enrich VSTA 2010 Use case diagram with SketchFlow Screens

Summary and reflections
I have many times over the years reflected over the lack of a good tools, or perhaps good enough tools, for UML modeling. Either you had a graphic library like Visio or a highly specialized tool for design with a steep learning curve, like Rational Rose/XDE. I hope and it feels like the VSTS2010 UML modeling tools could finally fill that gap and provide something in between Visio and the specialized tools. Let’s hope Microsoft package this so it can widely spread and used from all vsts editions.
Speaking about filling holes, I’m also impressed with the way it’s possible to tie together requirements modeling, specification and even test, out of the box in vsts2010.

In the next post I will take a look if and how the UML modeling tools in VSTS2010 can be used for analyzing and designing a system.

VSTS2010 team project creation - God and bad news

2009-09-28T00:48:00.006+02:00

The good news is that VSTS2010 has the capability to script team project creation out of the box. Grant Holliday wrote a post on Scripting Team Project Creation in TFS2010. As Grant states, this is a step in the right direction, earlier we had to relay on the power tool command line utility for creating team projects.

The bad news is that the 2010 version for scripting team project creation requires some GUI interaction and the VSTS beta requires the team explorer tab to be selected the last time Visual Studio was closed. I also look like VSTS2010 can’t create team project for TFS2008 through scripting.
Hopefully this can be fixed before the RTM version.

VSTS 2010 Readiness

2009-09-08T21:59:00.011+02:00

VSTS 2010 has been around for a while now, at least in some kind. It’s actually two years now, counting from the first Rosario CTP in August 2007. With Microsoft moving into beta 1 and soon beta 2 it feels like the time to get ready for the future is here.
As a first step for more serious effort I decided to do a test upgrade of our central TFS server, containing about 70 team projects. The goal was to test the upgrade process, and to get a real environment and real data for future tests. The install/configuration/upgrade process was a pleasant experience, running without any problems or errors. After upgrading I had to r run Hakan Eskicis script http://blogs.msdn.com/hakane/archive/2009/05/20/sample-script-to-enable-new-features-in-upgraded-team-projects-tfs-2010-beta1.aspx to enable my old team projects with the new features, hopefully this will be included in the upgrade process in the feature.
Overall the test upgrade went smoothly without any problem, and I can sleep better knowing it works. I also have lots of real life projects and data to put the new vsts2010 features to realistic tests. Hopefully I can start using the new vsts2010 toolset to solve real life everyday problems.

TFS Admin, Part III - POC Extending TFS Warehouse

2009-08-21T22:13:00.016+02:00

If I had a dollar for every time I wished for the capability to configure and store metadata about team project in TFS, I could at least take a very long vacation. Using a custom list in SharePoint to keep track of team projects and their metadata is the best solution I've come up with so far, especially if you use it as a request queue. But it´s still a non integrated solution causing manually work if you want to do reporting or anything useful with it.

Extending TFS Warehouse with metadata
Having metadata in a SharePoint list, which I could write code against, and knowing that the TFS warehouse is extendable gave me the idea to feed the TFS warehouse with team project metadata. For this to work I need the team project names to be the same in both the SharePoint List and TFS. This should not be a big issue for anyone, especially if you use the SharePoint list as a request queue and automatically create team project as described in previous post.
My plan was to write a generic adapter for the TFS warehouse, extending the Team Project dimension in the warehouse with selected fields from the SharePoint list.

Writing a custom TFS Warehouse adapter
My plan was to write a generic adapter for the TFS warehouse, extending the Team Project dimension in the warehouse with selected fields from the SharePoint list.
After some research on MSDN I was ready to start. A custom adapter is simply a class implementing the 3 methods in IWareHouseAdapter, compiled into an assembly and deployed to a special folder. To implement the IWarehouseAdapter interface you have to write code to make
• Make Schema Changes to the TFS Warehouse and cube
• Make Data Changes, i.e. create rows in the database
• Handle Initializing, request to stop processing
The TFS API provides an object model for the warehouse, together with some good articles on msdn and Steve Wrights posts How I built a Team Foundation Server custom data warehouse adapter made it pretty easy writing the adapter and deploying it to the server.

Retrospective - the real challenges
In retrospective I can see that the biggest challenges had nothing to do with writing the adapter or handling a SharePoint custom list. Looking back I spent more time doing other stuff then writing the logic for the adapter. The other things taking most time from the real task were:

Testing and the test environment
Running the test environment (a virtual PC image of o complete TFS setup) locally on my old and slow laptop were not funny. In order to save time, I tried reinitializing the TFS warehouse between tests. But this took too long time, so I ended up with reverting the virtual my machine and setting up my environment for every test run. Maybe a better design/separation and mocking could have saved time in the end.

Trying to make the Warehouse over complex
My lack of real world experience from BI projects took me out on long journey trying to make a too complex warehouse in order to handle the metadata in a generic way. After many hours trying to implement the advanced model with the TFS API I consulted a colleague with real life experienced of BI project and went for a really simple design instead.

Handling configuration for the adapter dll
Needing to store some configuration and have it easily handled I thought that using a .config file for the dll would be the best fit. I simply added settings to the adapter project and used the Properties. Settings class. Things worked nice until I tried changing the value in the .dll.config file. As I was afraid of it didn’t work. After hours of fruitless search for a way to get the framework to actually read my config file, I gave up and derived a custom setting provider from LocalFileSettingsProvider, override the GetPropertyValue method reading the config file as an XML document. Once I decided to write my own settings provider was I was done in 15 minutes, but I wasted several hours looking for a better solution.

Reducing technical dept
As I needed to wrap a SharePoint list in this project to I started to break out the SharePointListWrapper into a utility project. One thing lead to another and in the end I ended up fixing some of the code for the Automated Order Process to.
Doing so I repackage the source for The Automated Order Process, although the code is in better shape, it is like the TeamProejctMetadataAdapter still a proof of concept.

http://cid-5d46cae8c0008cf0.skydrive.live.com/self.aspx/.Public/POC%20TeamProjectMetadataAdapter.zip

TFS Admin, Part II - POC Automated Order process

2009-08-12T11:09:00.050+02:00

Update: TFS2010 Automated team project creation

In this post we will look at a possible solution covering the team project order process. The solution covers the whole process from order entry to delivery notification and is based upon the requirements listed in the previous post.

A good start, but a long way to go
This is just a proof of concept, a quick hack to prove it’s possible to accomplish an automated team project order process. It's a long easy to go to a releasable product or project with error handling, tracing, packaging and deployment and so on. The best would be to get something like this integrated into the TFS product or into the TFS Admin tool

Architecture and design
One distinctive requirement is the configuration, collection and storage of metadata. As we already have a working instance of WSS, it falls naturally to use its capability of custom lists to handle metadata.

In order to make team project creation fully automated after approval, we would have to programmatically create new team projects. This capability is provided in the latest power tool command line util.
Managing user rights for SSRS, WSS and TFS is also a hard requirement to manage. Fortunately we have the TFS admin tool on Codeplex providing sourcecode for handling this requirement.
Of course some coding and usage of the TFS API is needed to stitch it together.

Creating the TeamProject list
In order to create the teamproject list and the order form I created a custom list at the root sharepoint site of my tfsserver, naming it to TeamProjects.

To this list I added core field as follow. I renamed the Title field to Project Name, added a people column named Project Administrator. I also added a choice column named Process Template with the exact process templates strings.

Under List versioning settings I activated Content Approval enabling a approval workflow.
I also added a view PendingCreation with the filter ApprovalStatus=Approved and TeamProjectCreated=No.

To make it easily accessible I added Quick Launch links to the list as well as to the TeamProjects: New Item form.

The result is a new form for requsting a team project as illustrated to the right.

Automating project creation puting it together
Now we need some code reading the list and creating team projects, giving the project administrator access rights, reassigning the workitems to the project administrator, applying enterprise standard access rights and policies. For the purpose of demonstrating how this can be done, I've put together a a simple solution. The complete solution is attatched as a ZIP file.

http://cid-5d46cae8c0008cf0.skydrive.live.com/self.aspx/.Public/POC%20AutomatedTeamProjectCreation.zip

Code walkthrough
I will also go through the code briefly starting with the main function holding it all together.

static void CreatePendingTeamProject()
{
string serverName = "http://teamsystem.sogeti.se";
string tfsServerPort = ":8080";
string tfsServerUrl = serverName + tfsServerPort;

string listName="TeamProjects";
string viewName="PendingCreation";

string projectNameCol = "LinkTitle";
string projectAdminCol="Project Admin";
string procTemplateCol = "Project template";
string projectCreatedCol = "TeamProjectCreated";

//Fetch an entry for a requested team project form sharepoint list
SharePointListWrapper spReqListWrapper = new SharePointListWrapper(serverName, "", listName, viewName);
ReqForTeamProject reqTP = spReqListWrapper.GetRequestForTeamProject(projectNameCol,procTemplateCol, projectAdminCol);

I have wrapped all access to the Sharepoint list in a special SharePointListWrapper class. The interesting things is in this method

public ReqForTeamProject GetRequestForTeamProject(string projectNameCol, string templateCol, string projectAdminCol)
{
SPSite site = new SPSite(ServerUrl);
SPWeb web = site.AllWebs[RelativeSiteUrl];
SPList myList = web.Lists[ListName];
SPView view = myList.Views[ViewName];
Console.WriteLine("Connected to sharepoint list");

if (myList.GetItems(view).Count > 0)
{
Console.WriteLine("Found a item");

SPListItem itm = myList.GetItems(view)[0];
ReqForTeamProject tp = new ReqForTeamProject();

tp.Id = itm.ID;
tp.Name = itm.GetFormattedValue(projectNameCol); //Project Name, Forced to use this cause Title is renamed.
tp.ProcTemplate = itm.GetFormattedValue(templateCol);
tp.ProjectAdmin = ((SPFieldUserValue)itm.Fields[projectAdminCol]
.GetFieldValue(itm[projectAdminCol].ToString()))
.User.LoginName; ;

Console.WriteLine(tp.ProcTemplate);
Console.WriteLine("Returning a Request for teamproject user " + tp.ProjectAdmin);

return tp;
}
else
{
return null;
}
}
The code opens a SharePoint list, and the view PendingCreation, select the first item if any. As you can see, I’ve used the Microsoft.SharePoint library for access to the SharePoint list. This will require the solution to be deployed at the server running WSS. If you want to deploy it elsewhere you have to use the WSS web services instead.

Back to the main function we check if we got a request to create teamproject.

if (reqTP != null)
{
//Create the Team Project
TFPTWrapper tftp = new TFPTWrapper(tfsServerUrl);
tftp.CreateTeamProject(reqTP.Name, reqTP.ProcTemplate);

The next thing in the code is the actual teamproject creation. This is done by calling the TFPT command line utility. Calling the command line utility is wrapped in the TFPTWrapper class, and the method CreateTeamProject simply builds a command line and execute it by starting a new process.

After the team project is successfully created, we need to give the project administrator access rights.

// Add rights to the ProjectAdmin
TFSAdminTooolWrapper admin = new TFSAdminTooolWrapper(tfsServerUrl);
admin.AddProjectAdmin(reqTP.ProjectAdmin, reqTP.Name);

To set the actual roles to TFS, WSS and RS we rely on the TFS Admintool. I have chosen to wrap a developing branch of the TFS AdminTool. The reason for this is that this branch has separated the code handling the actual tfs, WSS and RS servers into a separate project. making it possible to reference the dll file and not include the whole source for the TFS AdminTool.

This reduces the handing of setting user rights to this function

public void AddUser(string user, string teamProject, string tfsRole, string spRole, string rsRole)
{
TFSAdministrationTool.Proxy.Common.TfsAdminToolTracer.Initialize(null);
Console.WriteLine("Adding user with admin tool " + user);

TFSAdministrationTool.Proxy.ITeamFoundationServerProxy iTFSProxy = TFSAdministrationTool.Proxy.TeamFoundationServerProxyFactory.CreateProxy();
iTFSProxy.Connect(TFSServerUrl);
Console.WriteLine("Admin tool connected ");

iTFSProxy.SelectTeamProject(teamProject);
Console.WriteLine("Team project selected");

iTFSProxy.AddUserToRole(user, tfsRole);
Console.WriteLine("Added TFS role " +tfsRole);

iTFSProxy.SharePointAddUserToRole(user, spRole);
Console.WriteLine("Added WSS role " + spRole);

iTFSProxy.ReportingServiceAddUserToRole(user, rsRole);
Console.WriteLine("Added RS role " + rsRole);
}

public void AddProjectAdmin(string user, string teamProject)
{
AddUser(user, teamProject, "Project Administrators", "Full Control","Content Manager");

}

}

After adding the project administrator we need to setup standard access. In my case I made a xml config file containing the user, TFS, WSS & RS role to add. the users and roles are applied using the same TFSAdminToolWrapper.

//Setup standard team project security
StandardRightsXml stdRightXml = new StandardRightsXml("stdTeamProjectSecurity.xml");
foreach (UserRights stdUsr in stdRightXml.GetTeamProjectRights())
{
admin.AddUser(stdUsr.User, reqTP.Name, stdUsr.TfsRole, stdUsr.SpRole, stdUsr.RsRole);
}

All work items assigned to the creator of the teamproject must be reassigned to the new project administrator.

// Reassign all workitems to the new owner
TFSWorkItemStoreWrapper tfsWIStore = new TFSWorkItemStoreWrapper(tfsServerUrl);
tfsWIStore.ReAssignWI(reqTP.Name, reqTP.ProjectAdmin);

This is done through the TFS WorkitemStore API. Executing a query, opening the work items, and changing the AssignedTo field. This is wrapped into the TFSWorkItemStoreWrapper class.

public void ReAssignWI(string teamProject, string newOwner)
{
WorkItemStore wiStore = new WorkItemStore(TFSServerUrl);

WorkItemCollection wiLst = wiStore.Query(
" SELECT [System.Id], [System.AssignedTo], [System.Title] " +
" FROM WorkItems " +
" WHERE [System.TeamProject] = '" + teamProject + "' ORDER BY [System.WorkItemType], [System.Id]");

foreach (WorkItem itm in wiLst)
{
itm.Open();
itm.Fields["System.AssignedTo"].Value = newOwner;
itm.Save();
}
}
We also need to apply standard check-in policies to our new teamproject. I've made a xml config file containing the list of standard policies to apply to all project.

//Setup standard team project Policies
StandardPoliciesXml stdPoliciesXml = new StandardPoliciesXml("stdTeamProjectPolicies.xml");
TFSPolicyWrapper tfsPolicyStore = new TFSPolicyWrapper(tfsServerUrl);
tfsPolicyStore.AddCheckinPolicies(reqTP.Name, stdPoliciesXml.GetTeamProjectPolicies());

The code for applying policies is based on a postby Jakob Ehn and wrapped into the TFSPolicyWrapper.

public void AddCheckinPolicies(string teamProject, List StdPolicyLst)
{
List policiesToApply = new List();

TeamFoundationServer tfs = new TeamFoundationServer(TFSServerUrl);
VersionControlServer srvVC = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
TeamProject tp = srvVC.GetTeamProject(teamProject);

policiesToApply.AddRange(tp.GetCheckinPolicies());

foreach (TpPolicy WantedPolicy in StdPolicyLst)
{
Assembly policyAssembly = Assembly.LoadFile(WantedPolicy.PolicyAssembly);
object o = policyAssembly.CreateInstance(WantedPolicy.PolicyType);

if (o is IPolicyDefinition)
{
IPolicyDefinition def = o as IPolicyDefinition;

PolicyEnvelope[] checkinPolicies = new PolicyEnvelope[1];
bool foundPolicy = false;
foreach (PolicyType policyType in Workstation.Current.InstalledPolicyTypes)
{
if (policyType.Name == def.Type)
{
policiesToApply.Add(new PolicyEnvelope(def, policyType));
foundPolicy = true;
}
}
if (!foundPolicy)
{
throw new ApplicationException(String.Format("The policy {0} is not registered on this machine", def.Type));
}
}
else
{
throw new ApplicationException(String.Format("Type {0} in assembly {1} does not implement the IPolicyDefinition interface", WantedPolicy.PolicyType, WantedPolicy.PolicyAssembly));
}
}

if (policiesToApply.Count > 0)
{
tp.SetCheckinPolicies(policiesToApply.ToArray());
}
tp = null;
srvVC = null;
tfs.Dispose();
tfs = null;
}

In order to apply a policy to a project we must be able to load the policy. This will require all policies to be installed on the machine executing the program.

The last thing to do is to mark the request for a new teamproject as finished. This is done by updating the list item.

//Update the item
spReqListWrapper.UpdateRequestForTeamProject(reqTP,projectCreatedCol);
}

TFS Admin, Part I - Requirements for Team project creation

2009-08-03T01:00:00.024+02:00

After installing TFS, most organizations sooner or later comes across many questions how to handle team system administration in their organization. In this post I will take a look at one of the first questions, How to handle Team Project Creation. Unfortunately this is one of the dark spots in case of functionality in the team system package. I will look at the requirements for team project creation process based on my experience from different organizations.

Stakeholders
I will start by looking at different stakeholders to the process of team project administration.

The first and obvious stakeholder is the project manager or “customer” who needs a project environment for the team. In many organizations there simply isn’t any process for ordering a new team project. From the project manager perspective it is important that the process for ordering a new team project is clear and simple resulting in a ready to go environment.
The management needs to keep track of existing project and systems, requiring lots of metadata like customer or business area, process and/or system owner. This require the ability to define and store metadata or/and make connection to some external tool for handling metadata. It also requires the metadata to be reportable.
The architectural function is responsible for standards and policies within the organization. Today all efforts to establish and maintaining a mandatory list of policies have to be done manually. The architectural function needs to be able to define the list of policies, and have them automatically deployed to new team projects.
The TFS admin crew is obvious a stakeholder for team project creation. TFS Admin also requires meta data such as project owners, administrators, cost centers and so on. Today creation of team projects is a manual process handling gathering, creation and customization of metadata, policies and reassigning work items and user rights. The whole process should be automated to avoid unnecessary work and errors.
The stakeholders listed above is/or should always be involved in the team project creation process. In addition to this, other stakeholders such as IT Operations for setting up project , staging and production environments, and License managers for handling license could be involved in the process, requiring the process itself to be easily extendable and customizable.

The list of requirements
The functionality could be divided into user stories or use cases and described like this. In addition to the requirements listed there is a n general requirement to be able to extend and customize the process easily.

Defining organizations standard
• Easy configuration of project metadata.
• Configuration of organization standard user rights
• Configuration of organization standard check-in policies

Ordering team project
• Easy accessible ordering form
• Collection of core values (Project name, administrator, process template, description)
• Collection of project metadata
• Approval workflow

Automated team project creation
• project creation
• reassigning of work items
• Applying user rights for project administrator
• Applying standard user rights.
• Applying standard check-in policies
• Notifying project administrator upon completion

Reporting
• Project catalog
• Extending project metadata to the TFS warehouse

TFS Scorecard released on Codeplex

2009-07-21T12:29:00.003+02:00

Yesterday I released the TFS Scorecard project on codeplex. TFS Scorecard is a report with the goal to provide you insight in your TFS environment and your organizations Team System adaptation.

The TFS Scorecard actually started a long time ago, when I first saw Brian Harrys dogfooding posts on Microsoft Team System adaptation. I wanted to know what went on in my own backyard, and running Brian’s SQL queries was a good start. Later I came across a reporting services report made by Christian Nielsen as I upgraded it with the 2008 version of the queries.

Since then I have used the report internally and at different customers, running into new information needs and adding functionality along the way. It has helped me answer questions, motivating costs and activities and solving performance issues.

Moving the TFS Scorecard to Codeplex was made mainly to make it easily accessible for everyone. Have it helped me it could perhaps prove to be useful to others.

My circle of interest

2009-06-30T21:08:00.008+02:00

About a year ago I read Grant Hollidays post on What’s your circle of interest ? (the question originating from Paul Stovel). Grant’s post got me thinking about my own circles, I decided that if I ever started blogging, my first post would be to define my circles of interest. So here I am with my first post and my circles.
The Circles are defined as three categories like this:
Core
These are things I enjoy, care about, and follow as much as I can. When news breaks in these areas, I try to stay on top. I like to think I’m an expert in some of them, and have strong opinions on the rest.
Non-core
I find myself working with these things, or have a minor interest in them, but tend to follow announcements occasionally. I have opinions and will probably complain if I don’t like certain aspects of them, but I’m not about to start evangelising them.
I don’t care
The only time I spend in these things is to decide whether I care or not. I don’t really use them. I don’t pay much attention to them. I prefer not to work in any of these areas.

Drawing the circles and getting it down on paper was a bit harder than I anticipated from the start. As I struggled with it and the definitions I noticed that I looked at my topics from two different viewpoints. Some topics are in focus if I think from the point of doing the right thing to solve a business need; others are from the perspective of doing it right when developing a solution.