/// <summary>
/// Show builds details
/// </summary>
/// <param name="TeamProjectName"></param>
/// <param name="buildDef"></param>
private static void ListBuilds(string TeamProjectName, BuildDefinitionReference buildDef)
{
List <Build> builds = BuildClient.GetBuildsAsync(TeamProjectName, new List <int> {
buildDef.Id
}).Result;
if (builds.Count > 0)
{
Console.WriteLine("+====================BUILDS================================================================================");
Console.WriteLine("+ ID | NUMBER | STATUS | START DATE | FINISH DATE | COMMITS");
Console.WriteLine("+----------------------------------------------------------------------------------------------------------");
for (int i = 0; i < builds.Count && i < 10; i++)
{
var changes = BuildClient.GetBuildChangesAsync(TeamProjectName, builds[i].Id).Result;
Console.WriteLine(" {0, -12}|{1, -22}|{2, -17}|{3, -20}|{4, -20}|{5}", builds[i].Id, builds[i].BuildNumber, builds[i].Status,
(builds[i].StartTime.HasValue) ? builds[i].StartTime.Value.ToString() : "",
(builds[i].FinishTime.HasValue) ? builds[i].FinishTime.Value.ToString() : "", changes.Count);
}
}
else
{
Console.WriteLine("+=======================================================================================");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildDefinitionCard"/> class.
/// </summary>
/// <param name="buildDefinition">A build definition.</param>
public BuildDefinitionCard(BuildDefinitionReference buildDefinition)
{
buildDefinition.ThrowIfNull(nameof(buildDefinition));
this.Title = buildDefinition.Name;
this.Buttons.Add(new CardAction(ActionTypes.ImBack, Labels.Queue, value: FormattableString.Invariant($"queue {buildDefinition.Id}")));
}
/// <summary>
/// Converts a <see cref="BuildDefinitionReference"/> to an <see cref="AzureDevOpsBuildDefinition"/>.
/// </summary>
/// <param name="buildDefinitionReference">Build definition reference to convert.</param>
/// <returns>Converted build definition.</returns>
public static AzureDevOpsBuildDefinition ToAzureDevOpsBuildDefinition(this BuildDefinitionReference buildDefinitionReference)
{
buildDefinitionReference.NotNull(nameof(buildDefinitionReference));
return
(new AzureDevOpsBuildDefinition
{
Id = buildDefinitionReference.Id,
Name = buildDefinitionReference.Name,
QueueStatus = buildDefinitionReference.QueueStatus.ToAzureDevOpsDefinitionQueueStatus(),
});
}
public void Constructor()
{
var buildDefinition = new BuildDefinitionReference {
Id = 1, Name = "Build 1"
};
var target = new BuildDefinitionCard(buildDefinition);
target.Title.Should().Be(buildDefinition.Name);
target.Buttons.First().Value.Should().Be("queue 1");
}
private async Task <BuildDefinition> GetExistingDefinitionAsync(string definitionName, CancellationToken cancellationToken)
{
Logger.LogDebug("Attempting to get existing definition '{0}'.", definitionName);
var projectReference = await Context.GetProjectReferenceAsync(cancellationToken);
var sourceRepository = await Context.GetSourceRepositoryAsync(cancellationToken);
var buildClient = await Context.GetBuildHttpClientAsync(cancellationToken);
if (pipelineReferences == default)
{
var definitionReferences = await buildClient.GetDefinitionsAsync(
project : projectReference.Id,
path : Context.DevOpsPath
);
pipelineReferences = new Dictionary <string, BuildDefinitionReference>();
foreach (var definition in definitionReferences)
{
if (pipelineReferences.ContainsKey(definition.Name))
{
Logger.LogDebug($"Found more then one definition with name {definition.Name}, picking the first one {pipelineReferences[definition.Name].Id} and not {definition.Id}");
}
else
{
pipelineReferences.Add(definition.Name, definition);
}
}
Logger.LogDebug($"Cached {definitionReferences.Count} pipelines.");
}
BuildDefinitionReference definitionReference = null;
pipelineReferences.TryGetValue(definitionName, out definitionReference);
if (definitionReference != null)
{
Logger.LogDebug("Existing definition '{0}' found at '{1}'.", definitionName, definitionReference.GetWebUrl());
return(await buildClient.GetDefinitionAsync(
project : projectReference.Id,
definitionId : definitionReference.Id,
cancellationToken : cancellationToken
));
}
else
{
Logger.LogDebug("No definition named '{0}' was found.", definitionName);
return(null);
}
}
public Build QueueBuild(BuildDefinitionReference definition)
{
DefinitionReference definitionReference = new DefinitionReference();
definitionReference.Id = definition.Id;
definitionReference.Project = definition.Project;
Build build = new Build();
build.Definition = definitionReference;
build.Project = definition.Project;
var result = _buildClient.QueueBuildAsync(build).GetAwaiter().GetResult();
return(result);
}
public TestPlanWebApi.TestPlan UpdateTestPlan()
{
string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name;
// Get a testplan client instance
VssConnection connection = Context.Connection;
TestPlanHttpClient testPlanClient = connection.GetClient <TestPlanHttpClient>();
BuildDefinitionReference buildDefinition = this._getBuildReference();
TestOutcomeSettings testOutcomeSettings = new TestOutcomeSettings()
{
SyncOutcomeAcrossSuites = true
};
ReleaseEnvironmentDefinitionReference releaseEnvironmentDefinition = this._getReleaseEnvironmentDefinitionReference();
TestPlanWebApi.TestPlan newplan1;
Context.TryGetValue <TestPlanWebApi.TestPlan>("$newPlan1", out newplan1);
if (newplan1 != null)
{
int id = newplan1.Id;
TestPlanWebApi.TestPlanUpdateParams testPlanUpdateParams = new TestPlanWebApi.TestPlanUpdateParams()
{
Name = "updatedPlan1",
AreaPath = this._getArea(),
Iteration = this._getIteration(),
Description = "description of the test plan",
StartDate = DateTime.Now.AddDays(2),
EndDate = DateTime.Now.AddDays(9),
State = "Inactive",
BuildId = this._getBuildId(),
Revision = newplan1.Revision,
BuildDefinition = buildDefinition,
ReleaseEnvironmentDefinition = releaseEnvironmentDefinition,
TestOutcomeSettings = testOutcomeSettings
};
// update a test plan
TestPlanWebApi.TestPlan plan = testPlanClient.UpdateTestPlanAsync(testPlanUpdateParams, projectName, id).Result;
Context.Log("{0} {1}", plan.Id, plan.Name);
return(plan);
}
return(null);
}
/// <summary>
/// Gets the builds for the parameter <paramref name="settings"/>.
/// </summary>
/// <param name="log">The Cake log context.</param>
/// <param name="settings">Settings for getting the build.</param>
/// <returns>The builds or an empty list of builds if no builds were found for the <paramref name="settings"/>.</returns>
/// <exception cref="InvalidOperationException">If no build definition was found for the <paramref name="settings"/>.</exception>
internal static IEnumerable <AzureDevOpsBuild> GetAzureDevOpsBuilds(
ICakeLog log,
AzureDevOpsBuildsSettings settings)
{
log.NotNull(nameof(log));
settings.NotNull(nameof(settings));
var azureDevOpsBuilds = new List <AzureDevOpsBuild>();
using (var buildHttpClient = new BuildClientFactory().CreateBuildClient(settings.CollectionUrl, settings.Credentials, out var authorizedIdenity))
{
log.Verbose(
"Authorized Identity:\n Id: {0}\n DisplayName: {1}",
authorizedIdenity.Id,
authorizedIdenity.DisplayName);
BuildDefinitionReference buildDefinition = null;
if (!string.IsNullOrEmpty(settings.BuildDefinitionName))
{
buildDefinition = GetBuildDefinition(log, buildHttpClient, settings);
if (buildDefinition == null)
{
throw new InvalidOperationException($"Build definition '{settings.BuildDefinitionName}' not found");
}
}
List <int> buildsDefinitionIds =
buildDefinition == null ? null : new List <int>()
{
buildDefinition.Id
};
List <Build> builds = null;
if (settings.ProjectGuid != Guid.Empty)
{
builds =
buildHttpClient
.GetBuildsAsync(
settings.ProjectGuid,
definitions: buildsDefinitionIds,
statusFilter: settings.BuildStatus?.ToBuildStatus(),
resultFilter: settings.BuildResult?.ToBuildResult(),
queryOrder: settings.BuildQueryOrder?.ToBuildQueryOrder(),
branchName: settings.BranchName,
top: settings.Top,
maxBuildsPerDefinition: settings.MaxBuildsPerDefinition)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
else if (!string.IsNullOrWhiteSpace(settings.ProjectName))
{
builds =
buildHttpClient
.GetBuildsAsync(
settings.ProjectName,
definitions: buildsDefinitionIds,
statusFilter: settings.BuildStatus?.ToBuildStatus(),
resultFilter: settings.BuildResult?.ToBuildResult(),
queryOrder: settings.BuildQueryOrder?.ToBuildQueryOrder(),
branchName: settings.BranchName,
top: settings.Top,
maxBuildsPerDefinition: settings.MaxBuildsPerDefinition)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
else
{
throw new ArgumentOutOfRangeException(
nameof(settings),
"Either ProjectGuid or ProjectName needs to be set");
}
azureDevOpsBuilds.AddRange(builds.Select(x => new AzureDevOpsBuild(log, settings, x)));
}
log.Verbose(
"{0} builds found",
azureDevOpsBuilds.Count);
return(azureDevOpsBuilds);
}
private IBuildDefinition Convert(BuildDefinitionReference definition)
{
return(new TfsBuildDefinition(definition));
}
public TaskContext(TestResultSyncTaskOptions task, BuildDefinitionReference buildDefinitionReference)
{
Task = task;
BuildDefinitionReference = buildDefinitionReference;
}
public static string GetWebUrl(this BuildDefinitionReference definitionReference)
{
var referenceLink = (ReferenceLink)definitionReference.Links.Links["web"];
return(referenceLink.Href);
}
