Best Practices when customizing Work Items in Team Foundation Server (TFS)


So I’ve been thinking a lot lately about how to customize work items while still making sure the TFS instance is able to upgrade smoothly to future versions. In my Internet research, I actually came upon a good article on this from of all sources, Rational (Microsoft’s main competitor). This is due to the fact that they use almost the exact same data model for work items in their product (Rational Team Concert) as TFS does. They both even call them work items! Anyways, the article does a good job of dividing customization’s into “Safe”, “Cautious”,and “Harmful”. Based on my experience and expertise, these are some good principles to follow when customizing work items in a process template. You don’t want to over customize and be stuck on TFS 2005 for the next 10 years!
Enjoy!

https://jazz.net/library/article/1002

About these ads

A Review of TeamSpec – a TFS plug-in for MS Word


Two years ago I did an evaluation of TeamSpec and pointed out some areas of improvement. I’m very happy to report that the company took these to heart and updated their product to address these. Here is my updated review based on TeamSpec v.4.2.1.

TeamSpec is a 3rd-party add-in for MS Word that connects it to Team Foundation Server.  It works with the newest version of TFS 2012 and Office (2013).  It is the only commercial add-in for Word currently on the TFS platform. There are other companies that have add-in’s as part of their overall suite or solution, but TeamSpec is the only product to concentrate on just Word and it does it quite well.

How It Works

Work item attributes are linked to sentences or words in your Word Document.  This is a bi-directional sync between TFS and Word.  For example, say you have  a requirement work item with the ID of 3 and the title is “Login to system”.  You could create a line in Word with the tool like so:

REQ ID 3 – Login to System, State: Proposed

When you changed the state of the requirement work item from “Proposed” to “Active” in TFS, the line would change in Word to:

REQ ID 3 – Login to System, State: Active

This could also be done the other way by changing the state in Word and publishing the change to TFS.

Additionally, you can create “Skins” which are basically pre-defined layouts for work items. You could say that you want the state of work items to always be in bold and italicized in a skin for example.

Added Functionality

The new functionality that I really like and makes it a valuable product is the ability to use work item queries from TFS with Word. Writing custom reports in Reporting Services for Word is not easy, especially since the HTML fields are not stored in the TFS Data Warehouse. This product makes it a cinch! No more writing a huge SRS! Just generate it! :)

Linked worked items are supported in queries and test cases are supported as well!!! So you can do your testing documents here as well.

The documentation has improved tremendously, but a few more “behind-the-scenes” articles in the documentation would be nice. I also hold some small reservations about the long term stability of the company as it appears to be small, so be sure to ask for the source code when you buy the product. But to be fair, they have been in business since 2005.

Conclusion

I highly recommend you look at this product if you are using TFS as your ALM platform. Microsoft majorly overlooked Word integration in TFS (although they got Excel and Project), but alas, this is where partners like TeamSolutions step in! Thank you TeamSolutions for stepping in so well!

Use the TFS Process Template used by Microsoft


Found this interesting post that explains the “ISD” process template that is used by Microsoft Consulting Services. I always get asked by customers what Microsoft uses for TFS, well now here’s a process template used by a branch of MS. Enjoy!

TFS on Azure is publicly available!


Brian Harry announced it today on his blog.  I’ve tried it out and it’s awesome!  They’ve got much of what you would find on a local tfs install, but of course it’s using the new tfs 2012 stuff and the web access is much better.  They’ve got the Scrum 2.0, CMMI 6.0, and Agile 6.0 templates to choose from, but they all have a “Scrum-ish” feeling to them.  For instance the CMMI one has a backlog!  Interesting development….

Go check it out today and use it while it’s still free!

New Application Lifecycle Management (ALM) Group in Washington, DC Area!


Are you interested in Software Engineering?  How to use ALM tools to make your software development organization?  Then come join us on Thursday, June 21 for the inaugrual meeting of the DC ALM Group!  Hope to see you there!

Kick-Off and Continuous Deployment with Team Foundation Server

GovDev Process Template for TFS 2010


I have collaborated with Microsoft through my company CEI to create a new process template for TFS.  It is tailored to Government clients that have requirements like CMMI, but also want to be agile.  The main work item we have added is a Use Case.  It is intended to be the child of Requirement work items and replaces the User Story work item in the Agile template.  Many of the work item queries from the Agile template have been integrated into the GovDev Process Template. The following graphic nicely shows how the linking between work items is intended to be done.

GovDev Process

One of the most significant reports added was the Requirements Traceability Matrix!  I have heard many clients ask for this in the past, especially in regards to government requirements.  A screenshot is given below.

RequirementsTraceabilityReport

The best part is this is all open source!  Here’s the link to the Codeplex site, go download it today!

Team Foundation Server on Windows Azure Preview!


Brian Harry just announced on his blog that a preview is available for TFS on Azure.  If you’d like to get in, I can hand out 5 accounts to this service.  Soooo, as a reward to my readers, the first 5 people to comment on this post will get an account from me.

Thanks!

Introduction to Visual Studio Database Management


Types of Projects

There are basically two types of projects available to you in Visual Studio 2010 (VS): Database and Server projects. You will see these options when you go to create a new project in VS.

image

Figure 1: Visual Studio Create Project Dialog Box

SQL Server 2005 projects are circled and separated from SQL Server 2008 projects. The “Wizard” project just gives you a step-by-step wizard to follow at the setup of a project; but is still either a server or database project. The difference between the two types of projects is the type of database objects they are intended to hold. Server projects hold logins, linked servers, asymmetric keys, and other objects that are configured at the SQL Server instance level. As you might guess, the database project holds objects that are defined at the database level such as tables, indexes, stored procedures, etc. Going forward I will mostly refer to database projects and almost everything that goes for them also goes for server projects.

Build and Deploy

One of the most important things to understand initially is how a database project is built and deployed. These are two separate processes and we will treat them as such.

Building a database project

When you build a database project a .dbschema file is produced. This file is an xml representation of every object in that database project. Here is a sample of what a table would look like:

<Element Type="ISql100Table" Name="[dbo].[CustomerCustomerDemo]">
  <Property Name="IsAnsiNullsOn" Value="True" />
  <Relationship Name="Columns">
    <Entry>
      <Element Type="ISql100SimpleColumn" Name="[dbo].[CustomerCustomerDemo].[CustomerID]">
        <Property Name="IsNullable" Value="False" />
        <Relationship Name="TypeSpecifier">
          <Entry>
            <Element Type="ISql90TypeSpecifier">
              <Property Name="Length" Value="5" />
              <Relationship Name="Type">
                <Entry>
                  <References ExternalSource="BuiltIns" Name="[nchar]" />
                </Entry>
              </Relationship>
            </Element>
          </Entry>
        </Relationship>
      </Element>
    </Entry>
    <Entry>
      <Element Type="ISql100SimpleColumn" Name="[dbo].[CustomerCustomerDemo].[CustomerTypeID]">
        <Property Name="IsNullable" Value="False" />
        <Relationship Name="TypeSpecifier">
          <Entry>
            <Element Type="ISql90TypeSpecifier">
              <Property Name="Length" Value="10" />
              <Relationship Name="Type">
                <Entry>
                  <References ExternalSource="BuiltIns" Name="[nchar]" />
                </Entry>
              </Relationship>
            </Element>
          </Entry>
        </Relationship>
      </Element>
    </Entry>
  </Relationship>
  <Relationship Name="Owner">
    <Entry>
      <References ExternalSource="BuiltIns" Name="[dbo]" />
    </Entry>
  </Relationship>
</Element>

From a visual perspective, this is what happens when building a database project:

Figure2

Figure 2: Database Project Build

This is just an introduction and more detailed reference can be found on MSDN.

Deploying a Database Project

Deploying a database project is essentially taking the model of the database given by the .dbschema file from the build and comparing it with a target database. From that comparison, a T-SQL script will be generated that will alter the target database to be in synch with the database represented by the database project. A command line tool called VSDBCMD.exe is used to do the deployment. A reference for it can be found here (http://msdn.microsoft.com/en-us/library/dd193283.aspx).

Here again is a visual diagram of what happens during deployment.

Figure3

Figure 3: Database Project Deployment Process

Parts of Database Project

A database project is laid out the following way by Visual Studio.

image

Figure 4: VS Layout of Database Projects

Basically, there are project property files, references, data generation plans, schema comparisons, database objects (divided by schema), and manual scripts.

Database Object Files

Database Object files are all the .sql files that create and maintain tables, stored procedures, indexes, etc. Below is a look on how they are organized by Visual Studio. I have not expanded every folder, but you should get a general sense of how .sql files are organized from this screenshot of solution explorer.

image

Figure 5: Visual Studio Database Object Files

Most .sql files use the “CREATE” T-SQL keyword. For example, here is the script for a stored procedure:

image

Figure 6: .sql file in Visual Studio

Here is the script for an index:

CREATE NONCLUSTERED INDEX [CategoriesProducts]
    ON [dbo].[Products]([CategoryID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF, ONLINE = OFF, MAXDOP = 0)
    ON [PRIMARY];

.dbproj File

This file defines the database project and instructs MSBUILD on how exactly to compile the database project. This is analogous to the .csproj file for a C# project. You also have the usual two configurations of builds out of box: debug and release. A sample of the file is given below:

<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <OutputPath>.\sql\debug\</OutputPath>
    <BuildScriptName>$(MSBuildProjectName).sql</BuildScriptName>
    <TargetConnectionString>
    </TargetConnectionString>
    <TargetDatabase>
    </TargetDatabase>
    <TreatWarningsAsErrors>False</TreatWarningsAsErrors>
    <SuppressWarnings>
    </SuppressWarnings>
    <DeploymentConfigFile>Properties\Database.sqldeployment</DeploymentConfigFile>
    <SqlCommandVariablesFile>Properties\Database.sqlcmdvars</SqlCommandVariablesFile>
    <DeployToDatabase>False</DeployToDatabase>
  </PropertyGroup>

Database Property Files

These files set different properties in the database project, except for the .sqlpermissions file. This file is the place where database permissions are set rather than using a .sql script. You can multiple versions of these files to setup different scenarios for both build and deploy. Each file is xml, but is given a nice GUI by Visual Studio.

.sqlsettings File

This file contains database specific configuration settings, such as a backup policy and collation. All build configurations use the same .sqlsettings file and it is set in the following window.

image

Figure 7: VS GUI for choosing which .sqlsettings file to use

You can get to this window by right-clicking on the project and clicking “Properties”.

Server projects do not have a .sqlsettings file.

http://msdn.microsoft.com/en-us/library/dd193289.aspx

http://msdn.microsoft.com/en-us/library/bb386162.aspx

For a complete listing of these options and their descriptions, go to http://msdn.microsoft.com/en-us/library/ms190249(SQL.90).aspx. Here is a subset of them below:

Option Description Default value
ANSI_NULLS When ON is specified, all comparisons to a null value evaluate to UNKNOWN.When OFF is specified, comparisons of non-UNICODE values to a null value evaluate to TRUE if both values are NULL. OFF
ANSI_WARNINGS When ON is specified, errors or warnings are issued when conditions such as divide-by-zero occur or null values appear in aggregate functions.When OFF is specified, no warnings are raised and null values are returned when conditions such as divide-by-zero occur. OFF
ARITHABORT When ON is specified, a query is ended when an overflow or divide-by-zero error occurs during query execution.When OFF is specified, a warning message is displayed when one of these errors occurs, but the query, batch, or transaction continues to process as if no error occurred. OFF
QUOTED_IDENTIFIER When ON is specified, double quotation marks can be used to enclose delimited identifiers.When OFF is specified, identifiers cannot be in quotation marks and must follow all Transact-SQL rules for identifiers. OFF
NUMERIC_ROUNDABORT When ON is specified, an error is generated when loss of precision occurs in an expression.When OFF is specified, losses of precision do not generate error messages and the result is rounded to the precision of the column or variable storing the result. OFF
RECURSIVE_TRIGGERS When ON is specified, recursive firing of AFTER triggers is allowed.When OFF is specified, only direct recursive firing of AFTER triggers is not allowed. OFF

The .sqlsettings file looks like this when opened in Visual Studio:

image

Figure 8: VS GUI for .sqlsettings file

It is of course an xml file. Here is an abbreviated sample:

<?xml version="1.0" encoding="utf-8"?>
<CatalogProperties xmlns="urn:Microsoft.VisualStudio.Data.Schema.Package.CatalogProperties">
  <Version>1.0</Version>
  <Properties>
    <AllowSnapshotIsolation>False</AllowSnapshotIsolation>
    <AnsiNullDefault>True</AnsiNullDefault>
    <AnsiNulls>True</AnsiNulls>
    <AnsiPadding>True</AnsiPadding>
    <AnsiWarnings>True</AnsiWarnings>
    <ArithAbort>True</ArithAbort>
    <AutoClose>False</AutoClose>
    <AutoCreateStatistics>True</AutoCreateStatistics>
    <AutoShrink>False</AutoShrink>
    <AutoUpdateStatistics>True</AutoUpdateStatistics>
    <AutoUpdateStatisticsAsynchronously>False</AutoUpdateStatisticsAsynchronously>
  </Properties>
</CatalogProperties>

.sqldeployment File

This file contains deployment specific settings such as database name and target connection string. You can have one of these for each build configuration. This is what it looks like in Visual Studio:

image

Figure 9: VS GUI for .sqldeployment file

Here is an example of the actual xml behind the VS GUI:

<?xml version="1.0" encoding="utf-8"?>
<DeploymentConfigurationSettings xmlns="urn:Microsoft.VisualStudio.Data.Schema.Package.DeploymentConfigurationSettings" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Version>1.0</Version>
  <Properties>
    <AlwaysCreateNewDatabase>False</AlwaysCreateNewDatabase>
    <BlockIncrementalDeploymentIfDataLoss>True</BlockIncrementalDeploymentIfDataLoss>
    <DeployDatabaseProperties>True</DeployDatabaseProperties>
    <DeploymentCollationPreference>UseSourceModelCollation</DeploymentCollationPreference>
    <DoNotUseAlterAssemblyStatementsToUpdateCLRTypes>False</DoNotUseAlterAssemblyStatementsToUpdateCLRTypes>
    <GenerateDropsIfNotInProject>False</GenerateDropsIfNotInProject>
    <PerformDatabaseBackup>False</PerformDatabaseBackup>
    <SingleUserMode>False</SingleUserMode>
  </Properties>
</DeploymentConfigurationSettings>

.sqlcmdvars File

This file contains names and values for SQLCMD variables, which are used when you deploy a project. You may associate a different one with each build configuration. Initially the .sqlcmdvars file has three variables that aren’t set until deployment. The first variable is $(DatabaseName), and it contains the name of the target database to which you are deploying. The second variable is $(DefaultDataPath), and it contains the path in which the files for the database are stored on the target server. The third variable is $(DefaultLogPath), and it contains the path in which the log file for the database is stored on the target server.  The main use for this file currently is to replace the name of linked servers at deployment time.

.PreDeployment.sql and .PostDeployment.sql Files

These files are self-explanatory in that they are run before and after deployment. You can have only one of each of these files in a database project. If you would like to use more, you will need to use the :r option that is part of SQLCMD. More information can be found here:

http://msdn.microsoft.com/en-us/library/aa833281(VS.80).aspx

Hope you liked this intro and good luck!

New User Voice Site for TFS and Visual Studio!!!!


Microsoft just created a new site for suggesting new features for TFS and Visual Studio at:

http://visualstudio.uservoice.com/forums/121579-visual-studio

This is great and seems to be much better than the Connect site.  I’ve already voted for upgrading the usability in Microsoft Test Manager, centralizing permissioning, and so much more!!!!

http://visualstudio.uservoice.com/users/21614007-woody

Lovin’ it.

.vdproj Setup Projects and TFS Build 2010


So you’re using .vdproj setup projects are you?  And you want to automate them with TFS 2010?  Well, you’re in the right place, although I would recommend you start moving those setup projects to a msdeploy  solution.

First, to automate the building of .vdproj project, you’re going to need to write your own msbuild file because they are not in msbuild format and therefore TFS Build does not know what to do with them.  I found some good examples on the net on how to do this, but I updated mine a little for 2010.  Here it is:

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
  <Target Name="Build">
    <PropertyGroup>
            <DevEnv>$(ProgramFiles)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.com</DevEnv>
            <SolutionFile>$(MSBuildProjectDirectory)\MySolution.sln</SolutionFile>
            <ProjectFile>$(MSBuildProjectDirectory)\MySetupProject\MySetup.vdproj</ProjectFile>
            <Configuration>Release</Configuration>
    </PropertyGroup>
    <Exec
          Command="&quot;$(DevEnv)&quot; &quot;$(SolutionFile)&quot; /Rebuild &quot;$(Configuration)&quot;
          /Project &quot;$(ProjectFile)&quot; /ProjectConfig &quot;$(Configuration)&quot; /Log"
          ContinueOnError="false"
         IgnoreExitCode="false"
         WorkingDirectory="$(MSBuildProjectDirectory)" />
  </Target>
</Project>

After you’ve done that save the msbuild file as, for example, AutomatedSetupBuild.proj and add it to source control at the same level as the solution file you intend to build.  Then select it when you are creating your build definition.

One last thing on drops.  If you intend to create a drop, there is a twist.  TFS Build usually overwrites the “OutputPath” property in msbuild files to the “Binaries” folder on the build agent at build time.  Since the “OutputPath” property does not apply here, you will need to overwrite it in the .vdproj file.  Simply open the .vdproj file in a text editor and find the word “Release”.  Change the “OutputFilename” to “..\\..\\..\\Binaries\\*.msi”.  My .vdproj file had an “8:” prefixing the path which I simply left.

You’re done now.  Enjoy!

Follow

Get every new post delivered to your Inbox.