testfx/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsSummaryArtifactPostProcessor.cs at c4003d377b07e5edc8a77f41bb447fdbba5a78e0 · microsoft/testfx · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
using Microsoft.Testing.Extensions.Reporting;
using Microsoft.Testing.Platform;
using Microsoft.Testing.Platform.CommandLine;
using Microsoft.Testing.Platform.Extensions.ArtifactPostProcessing;
using Microsoft.Testing.Platform.Extensions.OutputDevice;
using Microsoft.Testing.Platform.Helpers;
using Microsoft.Testing.Platform.OutputDevice;

namespace Microsoft.Testing.Extensions.AzureDevOpsReport;

#pragma warning disable RS0051 // Internal processor implementation is not a compatibility contract.

internal sealed class AzureDevOpsSummaryArtifactPostProcessor(
    ICommandLineOptions commandLineOptions,
    IEnvironment environment,
    IOutputDevice outputDevice)
    : IArtifactPostProcessorRequiresPostProcessing, IOutputDeviceDataProducer
{
    internal const string FragmentArtifactKind = "microsoft.testing.azure-devops-summary-fragment";
    internal const string SummaryArtifactKind = "microsoft.testing.azure-devops-summary";
    internal const string Provider = "azure-devops";
    internal const string ProviderSlug = "azure-devops";

    private static readonly string[] SupportedArtifactKinds = [FragmentArtifactKind];
    private static readonly ArtifactPostProcessingMode[] SupportedPostProcessingModes = [ArtifactPostProcessingMode.TestModules];
    private readonly bool _isEnabled =
        (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsSummary)
            && AzureDevOpsConstants.IsRunningInAzureDevOps(environment))
        || commandLineOptions.IsOptionSet(ArtifactPostProcessingDispatcherToolCommandLine.ManifestOptionName);

    public string Uid => "Microsoft.Testing.Extensions.AzureDevOpsReport.SummaryPostProcessor";

    public string Version => ExtensionVersion.DefaultSemVer;

    public string DisplayName => AzureDevOpsResources.DisplayName;

    public string Description => AzureDevOpsResources.Description;

    public IReadOnlyList<ArtifactPostProcessingMode> SupportedModes => SupportedPostProcessingModes;

    public bool SupportsTruncatedRuns => true;

    public IReadOnlyList<string> SupportedKinds => SupportedArtifactKinds;

    public IReadOnlyList<string> SupportedFileExtensionsFallback => [];

    public Task<bool> IsEnabledAsync() => Task.FromResult(_isEnabled);

    public async Task<ProcessedArtifact?> ProcessAsync(
        IReadOnlyList<InputArtifact> inputs,
        string outputDirectory,
        ArtifactPostProcessingContext context,
        CancellationToken cancellationToken)
    {
        cancellationToken.ThrowIfCancellationRequested();

        CiRunSummaryAggregate aggregate = CiRunSummaryAggregation.ReadAndAggregate(inputs, Provider, context);
        string aggregationId = CiRunSummaryAggregation.CreateAggregationId(inputs);
        string markdown = AzureDevOpsSummaryReporter.BuildAggregateMarkdown(aggregate);
        string outputPath = CiRunSummaryAggregation.GetMergedOutputPath(outputDirectory, ProviderSlug, aggregationId);
        await CiRunSummaryAggregation.WriteOutputAsync(outputPath, markdown).ConfigureAwait(false);

        string[] requestedOutputPaths =
        [
            .. aggregate.Modules
                .Select(module => module.RequestedOutputPath)
                .Where(path => !RoslynString.IsNullOrWhiteSpace(path))
                .Distinct(PathComparer),
        ];
        string uploadPath = requestedOutputPaths is [string requestedOutputPath] ? requestedOutputPath : outputPath;
        if (!string.Equals(Path.GetFullPath(uploadPath), Path.GetFullPath(outputPath), PathComparison))
        {
            await CiRunSummaryAggregation.WriteOutputAsync(uploadPath, markdown).ConfigureAwait(false);
        }

        string uploadMarkerPath = outputPath + ".uploaded";
        if (!File.Exists(uploadMarkerPath))
        {
            string line = $"##vso[task.uploadsummary]{AzDoEscaper.Escape(uploadPath)}";
            await outputDevice.DisplayAsync(this, new AzureDevOpsCommandOutputDeviceData(line), cancellationToken).ConfigureAwait(false);
            await CiRunSummaryAggregation.WriteOutputAsync(uploadMarkerPath, aggregationId).ConfigureAwait(false);
        }

        return new ProcessedArtifact(
            outputPath,
            SummaryArtifactKind,
            AzureDevOpsResources.DisplayName,
            AzureDevOpsResources.Description);
    }

    private static StringComparison PathComparison
        => RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
            ? StringComparison.OrdinalIgnoreCase
            : StringComparison.Ordinal;

    private static StringComparer PathComparer
        => RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
            ? StringComparer.OrdinalIgnoreCase
            : StringComparer.Ordinal;
}

#pragma warning restore RS0051