[Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591

Closed
Feature
#10633
Closed
[Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
Feature
#10633
Assignees
azat-msft
Milestone
MSTest 4.4 / MTP 2.4

Description

@duranserkan
Duran Serkan (duranserkan)
opened on Aug 14, 2026

Summary

Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.

The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.

Background and Motivation

The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.

However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.

Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.

I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:

run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh

A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.

Real-world example and additional context from my LinkedIn post

Proposed Feature

For every failed test displayed under the Failures section, render a collapsible block similar to:

Namespace.TestClass.TestMethod — 2.40s

Exception:Xunit.Sdk.EqualException
Location:Tests/TestClass.cs:42

Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

Suggested behavior:

  • Display the fully qualified test name and duration in <summary>.
  • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
  • Include the complete failure explanation or exception message in the expanded body.
  • Include the exception type and stack trace when available.
  • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
  • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
  • Preserve the existing maximum-failure and summary-size limits.
  • Clearly indicate when failures or individual failure details are truncated.
  • Keep the existing GitHub error annotations unchanged.

If control over disclosure or summary size is desirable, an option such as the following could be added:

--report-gh-failure-details on|off

It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.

GitHub supports this presentation through expandable sections.

Alternative Designs

Keep details only in annotations and workflow logs

The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.

Display all failure details without collapsible sections

This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.

Display only the failure name and duration

Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.

Publish a TRX or HTML report

A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.

Metadata

Metadata

Assignees

Labels

No labels
No labels

Type

Feature

Projects

No projects

    Milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions

    , 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
     blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

    Skip to content
    [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
    Closed
    Feature
    #10633
    Closed
    [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
    Feature
    #10633
    Assignees
    azat-msft
    Milestone
    MSTest 4.4 / MTP 2.4
    Description
    @duranserkan
    Duran Serkan (duranserkan)
    opened on Aug 14, 2026
    Summary
    Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
    The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
    Background and Motivation
    The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
    However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
    Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
    I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
    run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
    A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
    Real-world example and additional context from my LinkedIn post
    Proposed Feature
    For every failed test displayed under the Failures section, render a collapsible block similar to:
    Namespace.TestClass.TestMethod — 2.40s
    Exception:Xunit.Sdk.EqualException
    Location:Tests/TestClass.cs:42
    Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

    Suggested behavior:
    • Display the fully qualified test name and duration in <summary>.
    • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
    • Include the complete failure explanation or exception message in the expanded body.
    • Include the exception type and stack trace when available.
    • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
    • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
    • Preserve the existing maximum-failure and summary-size limits.
    • Clearly indicate when failures or individual failure details are truncated.
    • Keep the existing GitHub error annotations unchanged.
    If control over disclosure or summary size is desirable, an option such as the following could be added:
    --report-gh-failure-details on|off

    It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
    GitHub supports this presentation through expandable sections.
    Alternative Designs
    Keep details only in annotations and workflow logs
    The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
    Display all failure details without collapsible sections
    This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
    Display only the failure name and duration
    Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
    Publish a TRX or HTML report
    A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
    Metadata
    Metadata
    Assignees
    Labels
    No labels
    No labels
    Type
    Feature
    Projects
    No projects
      Milestone
      Relationships
      None yet
      Development
      No branches or pull requests
      Issue actions
      
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

      Skip to content
      [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
      Closed
      Feature
      #10633
      Closed
      [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
      Feature
      #10633
      Assignees
      azat-msft
      Milestone
      MSTest 4.4 / MTP 2.4
      Description
      @duranserkan
      Duran Serkan (duranserkan)
      opened on Aug 14, 2026
      Summary
      Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
      The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
      Background and Motivation
      The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
      However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
      Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
      I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
      run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
      A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
      Real-world example and additional context from my LinkedIn post
      Proposed Feature
      For every failed test displayed under the Failures section, render a collapsible block similar to:
      Namespace.TestClass.TestMethod — 2.40s
      Exception:Xunit.Sdk.EqualException
      Location:Tests/TestClass.cs:42
      Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

      Suggested behavior:
      • Display the fully qualified test name and duration in <summary>.
      • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
      • Include the complete failure explanation or exception message in the expanded body.
      • Include the exception type and stack trace when available.
      • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
      • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
      • Preserve the existing maximum-failure and summary-size limits.
      • Clearly indicate when failures or individual failure details are truncated.
      • Keep the existing GitHub error annotations unchanged.
      If control over disclosure or summary size is desirable, an option such as the following could be added:
      --report-gh-failure-details on|off

      It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
      GitHub supports this presentation through expandable sections.
      Alternative Designs
      Keep details only in annotations and workflow logs
      The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
      Display all failure details without collapsible sections
      This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
      Display only the failure name and duration
      Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
      Publish a TRX or HTML report
      A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
      Metadata
      Metadata
      Assignees
      Labels
      No labels
      No labels
      Type
      Feature
      Projects
      No projects
        Milestone
        Relationships
        None yet
        Development
        No branches or pull requests
        Issue actions
        
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

        Skip to content
        [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
        Closed
        Feature
        #10633
        Closed
        [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
        Feature
        #10633
        Assignees
        azat-msft
        Milestone
        MSTest 4.4 / MTP 2.4
        Description
        @duranserkan
        Duran Serkan (duranserkan)
        opened on Aug 14, 2026
        Summary
        Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
        The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
        Background and Motivation
        The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
        However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
        Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
        I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
        run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
        A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
        Real-world example and additional context from my LinkedIn post
        Proposed Feature
        For every failed test displayed under the Failures section, render a collapsible block similar to:
        Namespace.TestClass.TestMethod — 2.40s
        Exception:Xunit.Sdk.EqualException
        Location:Tests/TestClass.cs:42
        Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

        Suggested behavior:
        • Display the fully qualified test name and duration in <summary>.
        • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
        • Include the complete failure explanation or exception message in the expanded body.
        • Include the exception type and stack trace when available.
        • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
        • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
        • Preserve the existing maximum-failure and summary-size limits.
        • Clearly indicate when failures or individual failure details are truncated.
        • Keep the existing GitHub error annotations unchanged.
        If control over disclosure or summary size is desirable, an option such as the following could be added:
        --report-gh-failure-details on|off

        It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
        GitHub supports this presentation through expandable sections.
        Alternative Designs
        Keep details only in annotations and workflow logs
        The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
        Display all failure details without collapsible sections
        This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
        Display only the failure name and duration
        Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
        Publish a TRX or HTML report
        A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
        Metadata
        Metadata
        Assignees
        Labels
        No labels
        No labels
        Type
        Feature
        Projects
        No projects
          Milestone
          Relationships
          None yet
          Development
          No branches or pull requests
          Issue actions
          
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

          Skip to content
          [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
          Closed
          Feature
          #10633
          Closed
          [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
          Feature
          #10633
          Assignees
          azat-msft
          Milestone
          MSTest 4.4 / MTP 2.4
          Description
          @duranserkan
          Duran Serkan (duranserkan)
          opened on Aug 14, 2026
          Summary
          Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
          The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
          Background and Motivation
          The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
          However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
          Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
          I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
          run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
          A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
          Real-world example and additional context from my LinkedIn post
          Proposed Feature
          For every failed test displayed under the Failures section, render a collapsible block similar to:
          Namespace.TestClass.TestMethod — 2.40s
          Exception:Xunit.Sdk.EqualException
          Location:Tests/TestClass.cs:42
          Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

          Suggested behavior:
          • Display the fully qualified test name and duration in <summary>.
          • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
          • Include the complete failure explanation or exception message in the expanded body.
          • Include the exception type and stack trace when available.
          • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
          • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
          • Preserve the existing maximum-failure and summary-size limits.
          • Clearly indicate when failures or individual failure details are truncated.
          • Keep the existing GitHub error annotations unchanged.
          If control over disclosure or summary size is desirable, an option such as the following could be added:
          --report-gh-failure-details on|off

          It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
          GitHub supports this presentation through expandable sections.
          Alternative Designs
          Keep details only in annotations and workflow logs
          The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
          Display all failure details without collapsible sections
          This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
          Display only the failure name and duration
          Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
          Publish a TRX or HTML report
          A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
          Metadata
          Metadata
          Assignees
          Labels
          No labels
          No labels
          Type
          Feature
          Projects
          No projects
            Milestone
            Relationships
            None yet
            Development
            No branches or pull requests
            Issue actions
            
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

            Skip to content
            [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
            Closed
            Feature
            #10633
            Closed
            [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
            Feature
            #10633
            Assignees
            azat-msft
            Milestone
            MSTest 4.4 / MTP 2.4
            Description
            @duranserkan
            Duran Serkan (duranserkan)
            opened on Aug 14, 2026
            Summary
            Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
            The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
            Background and Motivation
            The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
            However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
            Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
            I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
            run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
            A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
            Real-world example and additional context from my LinkedIn post
            Proposed Feature
            For every failed test displayed under the Failures section, render a collapsible block similar to:
            Namespace.TestClass.TestMethod — 2.40s
            Exception:Xunit.Sdk.EqualException
            Location:Tests/TestClass.cs:42
            Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

            Suggested behavior:
            • Display the fully qualified test name and duration in <summary>.
            • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
            • Include the complete failure explanation or exception message in the expanded body.
            • Include the exception type and stack trace when available.
            • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
            • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
            • Preserve the existing maximum-failure and summary-size limits.
            • Clearly indicate when failures or individual failure details are truncated.
            • Keep the existing GitHub error annotations unchanged.
            If control over disclosure or summary size is desirable, an option such as the following could be added:
            --report-gh-failure-details on|off

            It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
            GitHub supports this presentation through expandable sections.
            Alternative Designs
            Keep details only in annotations and workflow logs
            The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
            Display all failure details without collapsible sections
            This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
            Display only the failure name and duration
            Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
            Publish a TRX or HTML report
            A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
            Metadata
            Metadata
            Assignees
            Labels
            No labels
            No labels
            Type
            Feature
            Projects
            No projects
              Milestone
              Relationships
              None yet
              Development
              No branches or pull requests
              Issue actions
              
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

              Skip to content
              [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
              Closed
              Feature
              #10633
              Closed
              [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
              Feature
              #10633
              Assignees
              azat-msft
              Milestone
              MSTest 4.4 / MTP 2.4
              Description
              @duranserkan
              Duran Serkan (duranserkan)
              opened on Aug 14, 2026
              Summary
              Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
              The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
              Background and Motivation
              The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
              However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
              Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
              I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
              run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
              A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
              Real-world example and additional context from my LinkedIn post
              Proposed Feature
              For every failed test displayed under the Failures section, render a collapsible block similar to:
              Namespace.TestClass.TestMethod — 2.40s
              Exception:Xunit.Sdk.EqualException
              Location:Tests/TestClass.cs:42
              Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

              Suggested behavior:
              • Display the fully qualified test name and duration in <summary>.
              • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
              • Include the complete failure explanation or exception message in the expanded body.
              • Include the exception type and stack trace when available.
              • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
              • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
              • Preserve the existing maximum-failure and summary-size limits.
              • Clearly indicate when failures or individual failure details are truncated.
              • Keep the existing GitHub error annotations unchanged.
              If control over disclosure or summary size is desirable, an option such as the following could be added:
              --report-gh-failure-details on|off

              It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
              GitHub supports this presentation through expandable sections.
              Alternative Designs
              Keep details only in annotations and workflow logs
              The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
              Display all failure details without collapsible sections
              This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
              Display only the failure name and duration
              Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
              Publish a TRX or HTML report
              A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
              Metadata
              Metadata
              Assignees
              Labels
              No labels
              No labels
              Type
              Feature
              Projects
              No projects
                Milestone
                Relationships
                None yet
                Development
                No branches or pull requests
                Issue actions
                
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

                Skip to content
                [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections #10591
                Closed
                Feature
                #10633
                Closed
                [Microsoft.Testing.Extensions.GitHubActionsReport] Show failure details in collapsible step-summary sections#10591
                Feature
                #10633
                Assignees
                azat-msft
                Milestone
                MSTest 4.4 / MTP 2.4
                Description
                @duranserkan
                Duran Serkan (duranserkan)
                opened on Aug 14, 2026
                Summary
                Enhance Microsoft.Testing.Extensions.GitHubActionsReport so the GitHub Actions step summary includes actionable details for each failed test inside collapsible <details> / <summary> sections.
                The existing totals and failure list should remain compact and scannable. Each collapsible summary would display the failed test name and duration, while the expanded section would contain its failure message, exception type, stack trace, and source location when available.
                Background and Motivation
                The GitHub Actions reporter significantly improves the experience of investigating test runs by putting failures, skipped tests, annotations, and a clear summary directly in the workflow UI.
                However, the step summary currently lists only the fully qualified name of each failed test. The annotations emitted by GitHubActionsAnnotationReporter show the failure explanation and resolved source location, but they do not include the stack trace. These annotations are also easy to miss because the step summary naturally receives most of the attention.
                Additionally, the step summary already displays test durations in the “Slowest tests” section using the test name — duration format. Using the same presentation for failed tests would provide useful diagnostic context and make the summary visually consistent.
                I encountered this while using xUnit v3 with Microsoft.Testing.Platform through DRN.Framework.Testing:
                run: dotnet run --project DRN.Test.Unit/DRN.Test.Unit.csproj --no-build --verbosity minimal --configuration Release -- --report-gh
                A compact summary is useful, but expandable failure details would make the summary sufficient for many common failures without overwhelming the page.
                Real-world example and additional context from my LinkedIn post
                Proposed Feature
                For every failed test displayed under the Failures section, render a collapsible block similar to:
                Namespace.TestClass.TestMethod — 2.40s
                Exception:Xunit.Sdk.EqualException
                Location:Tests/TestClass.cs:42
                Expected: 42
Actual: 41
at Namespace.TestClass.TestMethod() in Tests/TestClass.cs:line 42

                Suggested behavior:
                • Display the fully qualified test name and duration in <summary>.
                • Use the same test name — duration presentation and duration formatting as the existing “Slowest tests” section.
                • Include the complete failure explanation or exception message in the expanded body.
                • Include the exception type and stack trace when available.
                • Include the resolved source file and line, preferably as a repository link when it can be generated reliably.
                • HTML-encode test-provided values before placing them in <summary> or other HTML elements.
                • Preserve the existing maximum-failure and summary-size limits.
                • Clearly indicate when failures or individual failure details are truncated.
                • Keep the existing GitHub error annotations unchanged.
                If control over disclosure or summary size is desirable, an option such as the following could be added:
                --report-gh-failure-details on|off

                It could default to on when both --report-gh and the step summary are enabled, while allowing users to retain the current compact behavior.
                GitHub supports this presentation through expandable sections.
                Alternative Designs
                Keep details only in annotations and workflow logs
                The annotations already show the failure explanation and resolved source location. However, they do not include the complete stack trace and are presented separately from the step summary, making them easy to overlook.
                Display all failure details without collapsible sections
                This provides the required information but makes summaries difficult to scan, particularly when several tests fail or stack traces are long.
                Display only the failure name and duration
                Adding duration to the existing failure list would be useful, but it would not address the primary need for the failure message, exception information, and stack trace.
                Publish a TRX or HTML report
                A separate report can contain richer information, but it requires another artifact or reporting step and does not provide the same immediate GitHub Actions summary experience.
                Metadata
                Metadata
                Assignees
                Labels
                No labels
                No labels
                Type
                Feature
                Projects
                No projects
                  Milestone
                  Relationships
                  None yet
                  Development
                  No branches or pull requests
                  Issue actions