Manage Tests
The following code sample shows how to enumerate, retrieve and schedule tests in a project by content levels. It enumerates all tests in a project and gives a project test summary for content level type.
A test can be mapped to at least one of the 6 content level types:
Basic
Functional
Reliability
Certification
Experiences
Optional
The sample also shows how we can schedule only "Basic" tests in a Project.
GetRollupsByContentLevel Sample
C#
// ------------------------------------------------------------------------------------------------
// <copyright file="GetRollupsByContentLevel.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// ------------------------------------------------------------------------------------------------
//[assembly: System.CLSCompliant(true)]
namespace Microsoft.Windows.Kits.Samples.ContentLevel
{
using System;
using System.Collections.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection;
/// <summary>
/// Sample code for getting test roll-up by content level
/// </summary>
public class GetRollupsByContentLevel
{
/// <summary>
/// Prevents a default instance of the <see cref="GetRollupsByContentLevel"/> class from being created.
/// </summary>
private GetRollupsByContentLevel()
{
}
/// <summary>
/// Entry point method for the sample application
/// </summary>
/// <param name="args">standard parameter arguments</param>
public static void Main(string[] args)
{
string controllerName;
string projectName;
if (args.Length == 2)
{
controllerName = args[0];
projectName = args[1];
}
else
{
Console.WriteLine("Usage:\tGetRollupsByContentLevel.exe [ControllerMachineName] [ProjectName]");
return;
}
// first we need to connect to the Server
ProjectManager manager = new DatabaseProjectManager(controllerName);
// load the project
Project project = manager.GetProject(projectName);
// Let's retrieve the new property that returns project test roll-up for each content level type
ReadOnlyCollection<ContentLevelRollupInfo> rollupSummaryByContentLevels = project.Info.RollupSummaryByContentLevels;
Console.Out.WriteLine("Roll-up summary by content level for project: '{0}'", projectName);
foreach (ContentLevelRollupInfo rollupInfo in rollupSummaryByContentLevels)
{
Console.Out.WriteLine("\tSummary for '{0}' level:", rollupInfo.ContentLevel);
Console.Out.WriteLine("\t\tFailedCount: {0}", rollupInfo.FailedCount);
Console.Out.WriteLine("\t\tNotRunCount: {0}", rollupInfo.NotRunCount);
Console.Out.WriteLine("\t\tPassedCount: {0}", rollupInfo.PassedCount);
Console.Out.WriteLine("\t\tRunningCount: {0}", rollupInfo.RunningCount);
Console.Out.WriteLine("\t\tTotalCount: {0}", rollupInfo.TotalCount);
Console.Out.WriteLine("\t\tStatus: {0}", rollupInfo.Status);
}
// Other existing properties in ProjectInfo will now only return roll-up counts for tests that are mapped to certification content level
// this to keep backwards compatibility with HCK 2.0 OM API
ProjectInfo projectInfo = project.Info;
Console.Out.WriteLine();
Console.Out.WriteLine("\tCurrent Roll-up properties should be same as the roll-up counts for 'Certification' level");
Console.Out.WriteLine("\t\tFailedCount: {0}", projectInfo.FailedCount);
Console.Out.WriteLine("\t\tNotRunCount: {0}", projectInfo.NotRunCount);
Console.Out.WriteLine("\t\tPassedCount: {0}", projectInfo.PassedCount);
Console.Out.WriteLine("\t\tRunningCount: {0}", projectInfo.RunningCount);
Console.Out.WriteLine("\t\tTotalCount: {0}", projectInfo.TotalCount);
Console.Out.WriteLine("\t\tStatus: {0}", projectInfo.Status);
}
}
}
Windows PowerShell®
. ..\Initialization.ps1
Clear-Host
$Manager = Initialize
#Load Project
$Project = $Manager.GetProject("SampleTestProject")
#Let's retrieve the new property that returns project test roll-up for each content level type
$RollupSummaryByContentLevels = $Project.Info.RollupSummaryByContentLevels
Write-Host ("Roll-up summary by content level for project: '{0}'" -f $Project.Name)
foreach ($RollupInfo in rollupSummaryByContentLevels)
{
Write-Host ("Summary for '{0}' level:" -f $RollupInfo.ContentLevel)
Write-Host ("FailedCount: {0}" -f $RollupInfo.FailedCount)
Write-Host ("NotRunCount: {0}" -f $RollupInfo.NotRunCount)
Write-Host ("PassedCount: {0}" -f $RollupInfo.PassedCount)
Write-Host ("RunningCount: {0}" -f $RollupInfo.RunningCount)
Write-Host ("TotalCount: {0}" -f $RollupInfo.TotalCount)
Write-Host ("Status: {0}" -f $RollupInfo.Status)
}
#Other existing properties in ProjectInfo will now only return roll-up counts for tests that are mapped to certification content level
#this to keep backwards compatibility with HCK 2.0 OM API
$ProjectInfo = $Project.Info
Write-Host ""
Write-Host "Current Roll-up properties should be same as the roll-up counts for 'Certification' level"
Write-Host ("FailedCount: {0}" -f $ProjectInfo.FailedCount)
Write-Host ("NotRunCount: {0}" -f $ProjectInfo.NotRunCount)
Write-Host ("PassedCount: {0}" -f $ProjectInfo.PassedCount)
Write-Host ("RunningCount: {0}" -f $ProjectInfo.RunningCount)
Write-Host ("TotalCount: {0}" -f $ProjectInfo.TotalCount)
Write-Host ("Status: {0}" -f $ProjectInfo.Status)
ScheduleTestsByContentLevel Sample
C#
// ------------------------------------------------------------------------------------------------
// <copyright file="ScheduleTestsByContentLevel.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// ------------------------------------------------------------------------------------------------
[assembly: System.CLSCompliant(true)]
namespace Microsoft.Windows.Kits.Samples.ContentLevel
{
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Windows.Kits.Hardware.ObjectModel;
using Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection;
/// <summary>
/// Sample code for enumerating tests by content level
/// </summary>
public class ScheduleTestsByContentLevel
{
/// <summary>
/// Prevents a default instance of the <see cref="ScheduleTestsByContentLevel"/> class from being created.
/// </summary>
private ScheduleTestsByContentLevel()
{
}
/// <summary>
/// Entry point method for the sample application
/// </summary>
/// <param name="args">standard parameter arguments</param>
public static void Main(string[] args)
{
string controllerName;
string projectName;
if (args.Length == 2)
{
controllerName = args[0];
projectName = args[1];
}
else
{
Console.WriteLine("Usage:\tScheduleTestsByContentLevel.exe [ControllerMachineName] [ProjectName]");
return;
}
// first we need to connect to the Server
ProjectManager manager = new DatabaseProjectManager(controllerName);
// load the project
Project project = manager.GetProject(projectName);
// Calling the default GetTests() method will now return tests that are mapped to certification content level
// this to keep backwards compatibility with HCK 2.0 OM API
IList<Test> tests = project.GetTests();
Console.Out.WriteLine("Assertion for all tests mapped to certification level should be true: {0}", tests.All(test => test.ContentLevels.Contains(ContentLevelType.Certification)));
/*
* Let's now get project test summary for all content levels.
*/
List<ContentLevelType> contentLevelTypes = new List<ContentLevelType>
{
ContentLevelType.Basic,
ContentLevelType.Functional,
ContentLevelType.Reliability,
ContentLevelType.Certification,
ContentLevelType.Experiences,
ContentLevelType.Optional
};
tests = project.GetTests(contentLevelTypes);
Console.Out.WriteLine("Test summary for project '{0}'", project.Name);
Console.Out.WriteLine("\t Basic tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Basic)));
Console.Out.WriteLine("\t Functional tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Functional)));
Console.Out.WriteLine("\t Reliability tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Reliability)));
Console.Out.WriteLine("\t Certification tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Certification)));
Console.Out.WriteLine("\t Experiences tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Experiences)));
Console.Out.WriteLine("\t Optional tests: '{0}'", tests.Count(test => test.ContentLevels.Contains(ContentLevelType.Optional)));
Console.Out.WriteLine("\t Total tests: '{0}'", tests.Count);
/*
* Scheduling tests based on Content level.
* Here, we use the existing project.GetTests() method and then filter tests for a specific content level ("Basic")
*/
// this will retrieve all jobs/tests that are tagged with "Basic" content level
tests = project.GetTests(new[] { ContentLevelType.Basic });
// this will schedule "Basic" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling 'Basic' test: '{0}'", test.Name);
test.QueueTest();
}
/*
* Scheduling tests based on multiple content levels
* Here, we use the existing project.GetTests() method and then filter tests for a specific set of content levels ("Basic" and "Reliability")
*/
// this will retrieve all jobs/tests that are tagged with "Basic" and "Reliability" content level
tests = project.GetTests(new[] { ContentLevelType.Basic, ContentLevelType.Reliability });
// this will schedule "Basic" and "Reliability" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling test: '{0}'", test.Name);
test.QueueTest();
}
/*
* Scheduling tests based on multiple content levels using the new method - project.GetTests(contentLevels)
* Here, we use the new method project.GetTests(contentLevels) to retrieve tests only for a specific set of content levels ("Functional" and "Reliability")
*/
// let's retrieve tests for "Functional" and "Reliability" content levels
List<ContentLevelType> contentLevels = new List<ContentLevelType>
{
ContentLevelType.Functional,
ContentLevelType.Reliability
};
tests = project.GetTests(contentLevels);
// this will schedule "Functional" and "Reliability" jobs/tests that we just retrieved
foreach (Test test in tests)
{
Console.Out.WriteLine("Scheduling test: '{0}'", test.Name);
test.QueueTest();
}
// calling GetTests(contentLevels) method with an empty list of content levels will return an empty set of tests
tests = project.GetTests(new List<ContentLevelType>());
Console.Out.WriteLine("Tests count should be zero. Count: {0}", tests.Count);
}
}
}
Windows PowerShell®
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.dll")
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.dbconnection.dll")
$ObjectModel = [Reflection.Assembly]::LoadFrom($env:WTTSTDIO + "Microsoft.Windows.Kits.Hardware.objectmodel.submission.dll")
$connectFileName = $env:WTTSTDIO + "connect.xml"
Write-Host Opening connection file $connectFileName
$connectFile = [xml](Get-Content $connectFileName)
$ControllerName = $connectFile.Connection.GetAttribute("Server")
$DatabaseName = $connectFile.Connection.GetAttribute("Source")
Clear-Host
$Manager = new-object -typename Microsoft.Windows.Kits.Hardware.ObjectModel.DBConnection.DatabaseProjectManager -Args $ControllerName, $DatabaseName
#Load Project
$Project = $Manager.GetProject("system test")
#let's define enumerations for all content levels
$BasicTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Basic
$FunctionalTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Functional
$ReliabilityTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Reliability
$CertificationTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Certification
$ExperiencesTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Experiences
$OptionalTestContentLevel = [Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]::Optional
# Calling the default GetTests() method will now return tests that are mapped to certification content level
# this to keep backwards compatibility with HCK 2.0 OM API
$Tests = $Project.GetTests()
Write-Host ("Assertion for all tests mapped to certification level should be true: {0}", ($Tests | where {-not $_.ContentLevels.Contains($CertificationTestContentLevel)}).Length -eq 0)
#Project test summary for each content levels.
$allContentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
@($BasicTestContentLevel, $FunctionalTestContentLevel, $ReliabilityTestContentLevel, $CertificationTestContentLevel, $ExperiencesTestContentLevel, $OptionalTestContentLevel) |% {$allContentLevels.Add($_)}
$allContentLevels
$Tests = $Project.GetTests($allContentLevels)
Write-Host ("Test summary for project {0}" -f $Project.Name)
Write-Host ("Basic tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($BasicTestContentLevel)}).Length)
Write-Host ("Functional tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($FunctionalTestContentLevel)}).Length)
Write-Host ("Reliability tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($ReliabilityTestContentLevel)}).Length)
Write-Host ("Certification tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($CertificationTestContentLevel)}).Length)
Write-Host ("Experiences tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($ExperiencesTestContentLevel)}).Length)
Write-Host ("Optional tests: {0}" -f ($Tests | where { $_.ContentLevels.Contains($OptionalTestContentLevel)}).Length)
Write-Host ("Total tests: {0}" -f ($Tests.Count))
#schedule all basic tests in the project
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
$contentLevels.Add($BasicTestContentLevel)
foreach($Test in $Project.GetTests($contentLevels))
{
Write-Host ("Scheduling 'Basic' test: {0}" -f $Test.Name)
$Test.QueueTest()
}
# Scheduling tests based on multiple content levels using the new method - project.GetTests(contentLevels)
# Here, we use the new method project.GetTests(contentLevels) to retrieve tests only for a specific set of content levels ("Functional" and "Reliability")
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
@($FunctionalTestContentLevel, $ReliabilityTestContentLevel) |% {$contentLevels.Add($_)}
foreach($Test in $Project.GetTests($contentLevels))
{
Write-Host ("Scheduling 'Basic' test: {0}" -f $Test.Name)
$Test.QueueTest()
}
#calling GetTests(contentLevels) method with an empty list of content levels will return an empty set of tests
$contentLevels = New-Object "System.Collections.Generic.List[Microsoft.Windows.Kits.Hardware.ObjectModel.ContentLevelType]"
$Tests = $Project.GetTests($contentLevels)
Write-Host ("Tests count should be zero. Count: {0}" -f $Tests.Count)
# Sample code for creating a new project and scheduling Basic tests
# create the project name
$now = [System.DateTime]::Now
$ProjectName = "SampleContentLevelTestProject $now"
$RootPool = $Manager.GetRootMachinePool()
$DefaultPool = $RootPool.DefaultPool
# create the pool
$TestPool = $RootPool.GetChildPools() | Where {$_.Name -eq "TestPool" }[0]
if ($TestPool -eq $null)
{
$TestPool = $RootPool.CreateChildPool("TestPool")
}
# move all machines in the default pool
$DefaultPool.GetMachines() | foreach {
write-host $_.Name
$DefaultPool.MoveMachineTo($_, $TestPool)
}
#reset all machines
$TestPool.GetMachines() | foreach { $_.SetMachineStatus([Microsoft.Windows.Kits.Hardware.ObjectModel.MachineStatus]::Ready, 1) }
#-----------
# Creating a project
#-----------
$Project = $manager.CreateProject($ProjectName)
Write-Host "created a project named : "$Project.Name
$OSPlatform = $TestPool.GetMachines()[0].OSPlatform
$ProductInstance = $Project.CreateProductInstance("My Product Instance",
$TestPool,
$OSPlatform)
# this will find all systems in the test pool, and return those as a list of system test targets
$data = $ProductInstance.FindTargetFromSystem()
# for now, just use the first one found
Write-Host "Creating a target for " $data[0].Name
$Target = $ProductInstance.CreateTarget($data[0])
write-Host Successfully created a Target for $Target.Name that has $Target.GetTests().Count tests
# Schedule "Basic" test - i.e., tests that is marked as "Basic" content level
# Get the first "Basic" test and schedule it
$Test = $Target.GetTests() | where { $_.ContentLevels.Contains($BasicTestContentLevel)}[0]
$Test.QueueTest()