Here are the steps to be followed to migrate test cases from the hosted service to an on-premise server :

• Download the tfs integration platform suite from https://tfsintegration.codeplex.com/ 

• Enable "Alternate credentials" for the hosted service by following the instructions provided here 

• Run the following command with the credentials that are used to run the TFS integration platform suite for the on premise TFS to add the user to the "Team foundation service accounts group" 

             TFSSecurity.exe /g+ "Team Foundation Service Accounts" n:USERNAME /server:SERVERNAME 

• Launch the TFS integration tool

• Create a new configuration and navigate to the "Team foundation Server" folder and select the "WorkItemTracking" configuration

• Specify the source and the destination servers and start the migration. This might take a while depending on the number of workitems present.

• Fixing broken shared step links : 

On opening test cases which contain shared steps, you might notice that the shared steps don’t show up or that the test case links to an incorrect shared step.  You can run the utility present here to fix this issue. 

Usage : UpdateSharedSteps.exe <Project Collection> <Project>

• Migration of action recordings : 

Migrating action recordings needs to be done using this utility. 

Usage : FixActionRecording <Hosted Service project collection url> <Hosted service project name> <Hosted service alt-credential user name> <Hosted service alt-credential password> <On-prem server project collection url> <On-prem server project name>

The utility downloads all action recording attachments from the hosted service and creates a dummy test plan, a test suite within that plan, adds the test cases which have an associated recording to this test suite, creates dummy test results and associates the action recordings with this test result . This is is required because all action recordings need to be associated with a test result as well. Thus a dummy test plan and some dummy test results would be created after running this tool.

The attached utility helps you to migrate action recordings from the TFS hosted service to an on premise server after the migration of the work items is done. It can be easily modified to migrate recordings from an on-prem to another on-prem server as well. The utility downloads the original action recordings from the source server and associates those with the migrated test case work items in the target server 

The utility downloads the action recording from the hosted service and creates a dummy test plan, test suite, adds the test cases which have an associated recording to this test suite, creates dummy test results and
associates the action recording with this test result .  This is is required because all action recordings need to be associated with a test result as well. Thus you might notice some additional test plans and test results which would be created after running this tool.

Prerequisites :

If you want to migrate from the TFS hosted service, you need to enable alternate credentials for it. See this blog post for details on how to do it.  

Usage :

FixActionRecording <Hosted Service project collection url> <Hosted service project name> <Hosted service alt-credential user name> <Hosted service alt-credential password> <On-prem server project collection url> <On-prem server project name>

Related :

Here is a blog posted which helps you to fix broken shared step links after migration.

FixActionRecording.zip

# Load Client Assembly 
[Reflection.Assembly]::Load(“Microsoft.TeamFoundation.Client, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”); 
[Reflection.Assembly]::Load(“Microsoft.TeamFoundation.TestManagement.Client, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”); 
[Reflection.Assembly]::Load(“Microsoft.TeamFoundation.TestManagement.Common, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”); 
  
# Define parameters 
$tfsCollectionUrl = “https://myserver:8080/tfs/DefaultCollection”; 
$projectName = "DefaultProject"; 
$planId = "1"; 
$suiteId = "7"; ;

# Connect to tfs 
$tfsCollection = [Microsoft.TeamFoundation.Client.TfsTeamProjectCollectionFactory]::GetTeamProjectCollection($tfsCollectionUrl); 
$tcmService = $tfsCollection.GetService([Microsoft.TeamFoundation.TestManagement.Client.ITestManagementService]); 
[Microsoft.TeamFoundation.TestManagement.Client.ITestManagementTeamProject] $tcmProject = $tcmService.GetTeamProject($projectName);

# Query for test plan/points 
$testPlansProperty = [Microsoft.TeamFoundation.TestManagement.Client.ITestManagementTeamProject].GetProperty("TestPlans").GetGetMethod();

$testPlans = $testPlansProperty.Invoke($tcmProject, "instance,public", $null, $null, $null);

$testPlan = $testPlans.Find($planId); 
$pointsQueryWiql = [string]::Format("SELECT * FROM TestPoint WHERE SuiteId={0}", $suiteId); 
$testPoints = $testPlan.QueryTestPoints($pointsQueryWiql);

foreach($testPoint in $testPoints){
   $testCase = $testPoint.TestCaseWorkItem;
   $parametersCount = $testCase.TestParameters.Count; 
   Write-Host("----------------------------------");
   Write-Host([string]::format("Id:{0} Title:{1}", $testCase.Id,$testCase.Title));
   Write-Host ("Parameters count: {0}" -f ($parametersCount));
   Write-Host ("Is test case parameterized: {0}" -f ($parametersCount -gt 0));
    if($parametersCount -gt 0){
        Write-Host("Iteration count: {0}" -f $testCase.Data.Tables[0].Rows.Count);
    }
}

FindParameterizedTestCases.ps1

The usage of the tool is :
FindTestCase <TestCaseId> <ServerUrl> <ProjectName>

TestCaseId - The id of the test case to be found.Eg : 515
ServerUrl- The server url . Eg : https://localhost:8080/tfs/DefaultCollection
ProjectName - The project name 

I present some sample code below to help with this issue. The code is fairly straightfoward. Do let me know if you have any questions / find any bugs in the code.

namespace FindTestCase 

{ 
using Microsoft.TeamFoundation.Client; 
using Microsoft.TeamFoundation.TestManagement.Client; 
using System; 
using System.Linq; 

class FindTestCase 
{ 
static void Main(string[] args) 
{ 
int testCaseId; 
 if (args.Count() < 3)
            {
                Console.WriteLine("Usage : FindTestCase <TestCaseId> <ServerUrl> <ProjectName>");
                return;
            }

            if (!int.TryParse(args[0], out testCaseId))
            {
                Console.WriteLine("The test case id must be an 
 integer");
                return;
            }
            string serverUrl = args[1];
            string projectName = args[2];

            var projectCollectionUri = new Uri(serverUrl);
            var projectCollection = TfsTeamProjectCollectionFactory.
            GetTeamProjectCollection(projectCollectionUri);
            ITestManagementTeamProject project = projectCollection.
            GetService<ITestManagementService>().GetTeamProject(
            projectName);

            foreach (ITestPlan testPlan in project.TestPlans.Query(
            "SELECT * from TestPlan"))
            {
                //Check if the test case is present in the plan
                if (testPlan.RootSuite.AllTestCases.Where(tc => tc.Id 
                == testCaseId).Count() > 0)
                {
                    //If the test case is present, dig deeper to find 
 the suite(s) where it is present
                    FindInSuites(testPlan.RootSuite, 
                    testCaseId);
                }
            }
        }

        static void FindInSuites(IStaticTestSuite testSuite, int testCaseId)
        {
            foreach (ITestSuiteEntry entry in testSuite.Entries)
            {
                if (entry.EntryType == TestSuiteEntryType.TestCase)
                {
                    if (entry.Id == testCaseId)
                    {
                        Console.WriteLine("Test suite Id : {0}, Test 
 suite title : {1}, Test plan id : {2}", 
                        testSuite.Id, testSuite.Title, testSuite.Plan.
                        Id);
                    }
                }
                else
                {
                    IStaticTestSuite staticSuite = entry.TestObject as 
                    IStaticTestSuite;

                    if (staticSuite != null)
                    {
                FindInSuites(staticSuite,testCaseId);
                        
                    }
                    else
                    {
                        //Check in query based or requirement based 
 suites which cannot contain another suite as 
 child
                        IDynamicTestSuiteBase dynamicSuite = entry.
                        TestObject as IDynamicTestSuiteBase;
                        if (dynamicSuite != null)
                        {
                            if (dynamicSuite.TestCases.Where(tc => tc.
                            Id == testCaseId).Count() > 0)
                            {
                                Console.WriteLine("Test suite Id : {0},
 Test suite title : {1}, Test plan id : 
                                {2}", dynamicSuite.Id, dynamicSuite.
                                Title, dynamicSuite.Plan.Id);
                            }
                        }
                    }
                }
            }
        }
    }
}

FindTestCase.zip