Administering Visual Studio Team Foundation Server 2012 Jump Start

Microsoft Visual Academy (a cloud-based learning experience focusing on Microsoft Technologies and hosted on the latest Microsoft Azure technology) offered course that learn how to make Team Foundation Server (TFS) better serve your team processes and the ways you communicate. For the person who sets up and customizes TFS infrastructure, you will learn how to better define the types of work items available and their attributes to fully leverage the TFS platform for application lifecycle management (ALM).

Adminthe course will be online on May 29, 2013

This course follows the criteria for exam 70-496 and will provide accelerated preparation for this important exam in the MCSD: ALM track.

Register Now here

Good Luck


Software Testing with Visual Studio 2012 Jump Start

Microsoft Visual Academy (a cloud-based learning experience focusing on Microsoft Technologies and hosted on the latest Microsoft Azure technology) offered course that help you to improve how your team manages test coverage to better mitigate issues throughout your organization’s development process. You can leverage the tools built into Visual Studio 2012 to track back work items and test cases to business goals and measurable requirements to make testing a valuable part of your application lifecycle management (ALM). 🙂


the course will be online on May 28, 2013

This course follows the criteria for exam 70-497 and will provide accelerated preparation for this important exam in the MCSD: ALM track.

Register Now here

Good Luck

Why can’t developers be good testers?

1. “Parental feelings” towards their code

Developers are emotionally linked to the stuff they write.  It may sound silly but it is hard to be objective towards the stuff you create.
For example, I know my kids are not perfect and still I am sure I would have a hard time if someone would come to me and starts criticizing them in any way (after all they are perfect, right? :) ) .

2. Focus on the “Positive Paths”

Development work is based on taking positive scenarios and enabling them on the product.  Most of their efforts are concentrated on how to make things work right, effectively, efficiently, etc.  The mental switch required to move them from a positive/building mind-set to a negative/what-can-go-wrong mind-set is not trivial and very hard to achieve in a short time.

3. Work based on the principle of simplifying of complex scenarios

One of the basic things a tester does as part of his work is to look for complex scenarios (e.g. do multiple actions simultaneously, or make an operation over and over again, etc) in order to break the system and find the bugs.  So we basically take a simple thing and look for ways in which we can complicate it.

On the other hand our developer counterparts are trained into taking a complex process or project and breaking it down into the smallest possible components that will allow them to create a solution (I still remember my shock in college the first time I understood that all a computer could do was work with AND, OR, NOT, NAND, NOR, XOR and XNOR operations on Zeros & Ones).

4. Inability to catch small things in big pictures

I can’t really explain the reason behind this one, but I have seen it many times in my testing lifetime.
One of the side-effects from becoming a good tester is to develop a sense to (almost unconsciously) detect what “doesn’t fit” in the picture.  The best way to describe it is by the feeling one gets when something “doesn’t fit” in the picture but we just can’t put our hand on it; then by applying some systematic processes we are able to find the specific problem.

5. Lack of end-to-end & real-user perspective

Do the nature of their tasks most developers concentrate on a single component or feature in their product, while they still maintain a vague idea of how their users work with their end-to-end system.
Testers need to have a much broader perspective of our products, we are required to understand and test them as a whole while using techniques that allow us to simulate the way users will eventually work in the real world.

An experienced tester sees a form and automatically starts thinking about the common bugs and failures he may find in it and starts testing for them.

Manual and Automation testing Challenges

    Software Testing has lot of challenges both in manual as well as in automation. Generally in manual testing scenario developers through the build to test team assuming the responsible test team or tester will pick the build and will come to ask what the build is about? This is the case in organizations not following so-called ‘processes’. Tester is the middleman between developing team and the customers, handling the pressure from both the sides. And I assume most of our readers are smart enough to handle this pressure. Aren’t you?

This is not the case always. Some times testers may add complications in testing process due to their unskilled way of working. In this post I have added most of the testing challenges created due to testing staff, developing staff, testing processes and wrong management decisions.

So here we go with the top challenges:

1) Testing the complete application:
Is it possible? I think impossible. There are millions of test combinations. It’s not possible to test each and every combination both in manual as well as in automation testing. If you try all these combinations you will never ship the product

2) Misunderstanding of company processes:
Some times you just don’t pay proper attention what the company-defined processes are and these are for what purposes. There are some myths in testers that they should only go with company processes even these processes are not applicable for their current testing scenario. This results in incomplete and inappropriate application testing.

3) Relationship with developers:
Big challenge. Requires very skilled tester to handle this relation positively and even by completing the work in testers way. There are simply hundreds of excuses developers or testers can make when they are not agree with some points. For this tester also requires good communication, troubleshooting and analyzing skill.

4) Regression testing:
When project goes on expanding the regression testing work simply becomes uncontrolled. Pressure to handle the current functionality changes, previous working functionality checks and bug tracking.

5) Lack of skilled testers:
I will call this as ‘wrong management decision’ while selecting or training testers for their project task in hand. These unskilled fellows may add more chaos than simplifying the testing work. This results into incomplete, insufficient and ad-hoc testing throughout the testing life cycle.

6) Testing always under time constraint:
Hey tester, we want to ship this product by this weekend, are you ready for completion? When this order comes from boss, tester simply focuses on task completion and not on the test coverage and quality of work. There is huge list of tasks that you need to complete within specified time. This includes writing, executing, automating and reviewing the test cases.

7) Which tests to execute first?
If you are facing the challenge stated in point no 6, then how will you take decision which test cases should be executed and with what priority? Which tests are important over others? This requires good experience to work under pressure.

8 ) Understanding the requirements:
Some times testers are responsible for communicating with customers for understanding the requirements. What if tester fails to understand the requirements? Will he be able to test the application properly? Definitely No! Testers require good listening and understanding capabilities.

9) Automation testing:
Many sub challenges – Should automate the testing work? Till what level automation should be done? Do you have sufficient and skilled resources for automation? Is time permissible for automating the test cases? Decision of automation or manual testing will need to address the pros and cons of each process.

10) Decision to stop the testing:
When to stop testing? Very difficult decision. Requires core judgment of testing processes and importance of each process. Also requires ‘on the fly’ decision ability.

11) One test team under multiple projects:
Challenging to keep track of each task. Communication challenges. Many times results in failure of one or both the projects.

12) Reuse of Test scripts:
Application development methods are changing rapidly, making it difficult to manage the test tools and test scripts. Test script migration or reuse is very essential but difficult task.

13) Testers focusing on finding easy bugs:
If organization is rewarding testers based on number of bugs (very bad approach to judge testers performance) then some testers only concentrate on finding easy bugs those don’t require deep understanding and testing. A hard or subtle bug remains unnoticed in such testing approach.

14) To cope with attrition:
Increasing salaries and benefits making many employees leave the company at very short career intervals. Managements are facing hard problems to cope with attrition rate. Challenges – New testers require project training from the beginning, complex projects are difficult to understand, delay in shipping date!

These are some top software testing challenges we face daily. Project success or failure depends largely on how you address these basic issues.

FAQ: What is the difference between “Assigned To” and “Tester” in MTM?

FAQ: In Microsoft Test Manager (MTM), what is the difference between the “Assigned To” field of the Test Case work item and the “Tester” field in MTM.  It seems these to fields are stored independently. So if I assign someone test cases through MTM then this is not translated into the “Assigned To” on the WIT.

A: The “Assigned To” is a field on the test case work item.  The “Tester” is a field on the Test Point artifact.  A Test Point is a Test Case * Test Configuration.  For example, for a given Test Case, you might want to test it on two different versions of the browser – so there are two Test Points.

The “Assigned To” field on the test case work item indicates who owns that test case from an authoring and ownership standpoint.  If anyone has questions in the future they can go to that person. This is the person who is suppose to maintain the test case.

The “Testers” column in the Plan & Test tabs of MTM indicates who will be executing that test case for that particular test configuration.  Since you can have multiple configurations for a single test case, you can “assign” a different tester to each of the configurations.  For example, irrespective of who wrote the test cases to start with, you might want to have a particular tester execute all tests on a given configuration (say IE9 on Win7) for efficiency.

What’s Team Foundation Service ?

Team Foundation Server is a mainstay of Microsoft’s collaboration platform for software development teams. It provides modern application lifecycle support for modern app development, including agile project planning and management tools, version control, build automation, and the continuous deployment automation needed to effectively and efficiently manage software development projects.

In addition to the value TFS provides to development teams targeting Windows, more and more we’re seeing it used in heterogeneous environments as well, whether developers are using Visual Studio or Eclipse or Xcode; whether developers are building apps with .NET or Java or C++ or JavaScript or any number of other languages; and whether developers are building apps for Windows, Windows Phone, Windows Azure, Android, iOS, MacOS, or Linux.  We’re also seeing the cloud become a key enabler across the lifecycle of applications.

Last year at the Build conference, we announced Team Foundation Service, a version of Team Foundation Server hosted on Windows Azure, accessible from anywhere using existing and familiar tools, and welcoming all languages and platforms.  Over the last year, we’ve run the service as a preview, and during this time we’ve continued to build out the breadth and depth of functionality included. Today, I’m very excited to share that Team Foundation Service is now released, out of preview and available for full production use.  Check it out for yourself at


Team Foundation Service includes a free usage plan with a robust set of features that make it quick and easy for individuals and lean teams to get started with this application lifecycle management (ALM) platform, and without the need to stand up their own hardware, manage backups, or keep the server up-to-date. It welcomes developers targeting Microsoft platforms and other platforms, with support not only in Visual Studio, Excel, and Project, but also for developers on Mac OS, Linux, Solaris, and HP-UX through Team Explorer Everywhere and the Git-TF command-line tools.  The free plan includes support for up to 5 users, an unlimited number of projects, version control, work item tracking, agile planning tools, feedback management, and build (the last of which is still in preview).

In addition, MSDN subscribers at the Visual Studio Test Pro with MSDN, Visual Studio Premium with MSDN, and Visual Studio Ultimate with MSDN levels will have use of the service included as a subscription benefit. For the time being, anyone can sign up and use the service for free.  We’ll be announcing more about paid plans and services in 2013.

With the many new computing platforms and development tools becoming available right now, it’s a great time to be a developer.  You can sign up for your own Team Foundation Service account at and see for yourself what a cloud-hosted, modern collaboration and ALM tool brings to your team.  We’re currently adding new features and capabilities to the service every three weeks or so, putting us in a great position to react to your needs and make adjustments based on your feedback.  Use it and let us know what you think.

New TFS Administration Tool


One of the tools any TFS admin keeps in their toolbox is the TFS Administration Tool. This tool makes it very easy to manage security for TFS. Allowing you to manage user permissions on all three platforms used by TFS. Specifically TFS, SharePoint and Reporting Services.

Download version 2.2 here.

The Gated Check-in build in TFS2010

Everybody should be already familiar with Continuous Integration or should I say Continuous Building? Automatically building a development codeline after a check-in is often not immediately followed by an integration action towards a main branch.

Apart from the fact how this “build automation” should be called, there are many reasons why you should enforce this behavior on different branch types for your applications. The ultimate goal is to improve the quality of the software application and to reduce the time to release the application in production. By setting up early validation (compilation, automatic testing + other quality gates) through “build automation” you will at least be notified as soon as possible of all kinds of validation errors (= quality check) and you will have a chance to fix them before other team members will be impacted by pulling a get latest on the repository.

Automatically firing a validation build after a check-in will in the end not prevent broken builds and that’s where the Gated Check-in Build will come into play with Team Foundation Server 2010.

The Gated Check-in Build in TFS2010 will prevent broken builds by not automatically committing your pending changes to the repository, but the system will instead create a separate shelveset that will be picked up by the Gated Check-in Build. The build itself will finally decide if the pending changes need to be committed to the repository based on the applied quality gates.


The picture above describes the full process of a Gated Check-In build.

How to setup a Gated Check-in build?

The Trigger Tab in the Build Definition window has now an extra option for selecting Gated Check-in.


At the moment a check-in is attempted by a developer in the branch where the Gated Check-in build is active, the developer will be faced with a dialog box.


Cancelling this window will not kick off the build, but will also not commit your pending changes to the repository. If you really want to overrule this build with committing your changes directly to the repository, you may select the 2nd checkbox to bypass the validation build (not recommended). By default your pending changes will reside in your local workspace (first checkbox). In the situation where you immediately want to start with new changes – not relying on previous changes – it might be appropriate to uncheck the first option.

In the ideal situation, the build will complete without any validation errors and will eventually commit the changes to the repository. This will also lead to a Gated Check-in notification for the original committer via the Team Build Notification tool.


If you had previously chosen to preserve the changes locally (default), you may have noticed that the files you were working on were still checked out during the build … and in fact after a successful build these changes do not reflect the as-is situation anymore of the repository. With the above window you get the option to immediately reconcile your workspace with the up-to-date repository. So, clicking the “Reconcile …” button will give you the opportunity to select the desired files to force an undo in your local workspace and to pickup the changes that were committed by the Gated Check-in build for these files.

Another way to reconcile your workspace (if you for example ignored this window or when the build notification is way too slow) is by right-clicking the completed Gated Check-in Build in the Build Explorer and selecting the option to reconcile your workspace.


If you did not choose to preserve the changes locally, there won’t be any changes to reconcile after the Gated Check-in build, even if you forced the reconciliation.


The Gated Check-in build may also be kicked off manually where you may need to create a shelveset or where you may point to an existing shelveset.


A last thing to note is that the comment that was originally supplied to the changeset by the developer will be suffixed with the NoCICheckinComment variable (default = ***NO_CI***) to prevent that another continuous integration build will be fired after the final check-in done by the Gated Check-in build.



What meant to be a small post on the Gated Check-in feature in Team Foundation Server 2010 ended up in a more detailed explanation of how it works and how you can work with it in the Visual Studio IDE. Remember that you should setup the most appropriate build types according to your specific branches. Not all branches may need a Gated Check-in build. Only configure this for branches that should never have a broken build. A Gated Check-in build may for example validate a big merge operation from a development branch to a stable main branch.


What’s New for Application Lifecycle Management in Visual Studio 2012

You can use Visual Studio Application Lifecycle Management (ALM) to manage your product lifecycle, reduce risks, and improve efficiencies. When you install or upgrade to Visual Studio Team Foundation Server 2012, you and your team can benefit from the new features and supported tasks outlined in the following table.

Lifecycle area New features and supported tasks
Planning and Tracking
  • Create and manage the product backlog, sprints, and tasks.
  • Run daily standups with a task board.
  • Support multiple teams within a team project.
  • Engage stakeholders to provide feedback about pre-release software.
  • Illustrate requirements with PowerPoint Storyboarding and link storyboards to work items.
  • Manage enterprise project portfolios and access up-to-date project status and resource availability using Microsoft Project Professional and Project Server.
Architecture, Modeling, and Design
  • Create, read, and edit dependency graphs faster and more easily.
  • Get more information about your work by opening and viewing linked model elements in work items.
  • Communicate with others about the design by creating UML class diagrams from C# code.
  • Implement your design more quickly by generating C# code from UML class diagrams.
  • Import UML class, use case, and sequence diagram elements from XMI 2.1 files.
Developer Tools
  • Work more efficiently by organizing work and reducing the impact of interruptions using My Work and Pending Changes.
  • Enhance transparency and collaborate more effectively to product quality code using Code Review.
  • Integrate testing into the developer workflow using Test Explorer.
  • Find duplicated code in a solution with Code Clone Analysis.
  • Collect diagnostic data for applications running on computers that don’t have Visual Studio by using the IntelliTrace standalone data collector.
  • Review Web requests in IntelliTrace recordings for ASP.NET Web applications hosted on IIS 7.0 or later.
  • Easily debug code generated from text templates. Quickly customize the code generator by writing Visual Studio extensions.
  • Conduct exploratory test sessions.
  • Locate, view, and edit your test methods, UI actions and their associated controls in the UI control map.
  • Quickly track your test plan progress using the Results tab in Microsoft Test Manager.
  • Clone your test plan to work on different releases in parallel.
  • Test Windows Store apps running on a remote device using manual tests or exploratory test sessions.
  • Install and configure agents more easily for Lab Management for Visual Studio 2012.
  • Include SCVMM (System Center) 2012 and clustered Hyper-V hosts in Lab Management for Visual Studio 2012.
Team Foundation Build
  • Define and run automated build processes in a hosted deployment of TFS by connecting it to an on-premises or hosted build controller.
  • Increase the efficiency of your gated check-in build process by configuring it to build multiple check-ins at the same time.
  • Run native and third-party framework unit tests using Visual Studio Test Runner or RunTests in a custom build process.
  • Easily access, organize, and get information about the builds that matter most to you using the Builds page in Team Explorer.
  • Debug builds more easily.
Version Control
  • Work in local workspaces either in or outside of Visual Studio, even when you’re not connected to Team Foundation Server.
  • Manage your work, reduce the impact of interruptions, and facilitate collaboration with your team with My Work and Pending Changes pages in Team Explorer.
  • Conduct and track reviews of active, suspended, or checked-in code.
  • Manage shelvesets and changesets using My Work and Pending Changes.
  • Review and modify code changes more easily using the enhanced Diff window.

For More details :

Download Visual Studio 2012

Data Driven Testing with Visual Studio 2012 – Coded UI Test

In Visual Studio 2010 we use Test View Window and Data Source Wizard to create data driven Coded UI test case.

In Visual Studio 2012, the Test View Window and Data Source Wizard are no longer available.

You will have to insert the [Data Source] attribute directly in the code in the line immediately above your [Test Method].

Sample Data Source strings are given below. Copy them to your code and make the necessary customizations.

Data Source Type Data Source attribute
CSV [DataSource(“Microsoft.VisualStudio.TestTools.DataSource.CSV”, “|DataDirectory|\\data.csv”, “data#csv”, DataAccessMethod.Sequential), DeploymentItem(“data.csv”), TestMethod]
Excel DataSource(“System.Data.Odbc”, “Dsn=Excel Files;Driver={Microsoft Excel Driver (*.xls)};dbq=|DataDirectory|\\Data.xls;defaultdir=.;driverid=790;maxbuffersize=2048;pagetimeout=5;readonly=true”, “Sheet1$”, DataAccessMethod.Sequential), TestMethod]
Test Case in TFS [DataSource(“Microsoft.VisualStudio.TestTools.DataSource.TestCase”, “http://vsalm:8080/tfs/DefaultCollection;FabrikumFiber”, “30”, DataAccessMethod.Sequential), TestMethod]
XML [DataSource(“Microsoft.VisualStudio.TestTools.DataSource.XML”, “|DataDirectory|\\data.xml”, “Iterations”, DataAccessMethod.Sequential), DeploymentItem(“data.xml”), TestMethod]
SQL Express [DataSource(“System.Data.SqlClient”, “Data Source=.\\sqlexpress;Initial Catalog=tempdb;Integrated Security=True”, “Data”, DataAccessMethod.Sequential), TestMethod]
Other types here