) => void>();
+ const addEventListener = vi.fn<(type: string, listener: (event: TrackEvent) => void) => void>();
+ const console = { debug: vi.fn(), warn: vi.fn() };
+ const context = {
+ location: { origin },
+ window: {},
+ document: { addEventListener },
+ console,
+ oneDS: {
+ ApplicationInsights: class {
+ initialize = initialize;
+ capturePageAction = capturePageAction;
+ },
+ },
+ };
+ const bootstrap = () => { runInNewContext(read('public/scripts/analytics/1ds.js'), context); };
+ const tracking = () => { runInNewContext(read('public/scripts/analytics/track.js'), context); };
+ return { initialize, capturePageAction, addEventListener, console, bootstrap, tracking };
+}
+
+test('analytics excludes unload without disabling other lifecycle or click capture', () => {
+ const fixture = analyticsFixture();
+ fixture.bootstrap();
+ fixture.bootstrap();
+ expect(fixture.initialize).toHaveBeenCalledOnce();
+ expect(fixture.initialize.mock.calls[0][0]).toMatchObject({
+ disablePageUnloadEvents: ['unload'],
+ webAnalyticsConfiguration: {
+ autoCapture: { onUnload: true, click: true, pageView: true },
+ },
+ });
+ expect(fixture.console.debug).not.toHaveBeenCalled();
+ expect(fixture.console.warn).not.toHaveBeenCalled();
+});
+
+test('analytics and tracking remain inactive on other origins', () => {
+ const fixture = analyticsFixture('http://localhost:4321');
+ fixture.bootstrap();
+ fixture.tracking();
+ expect(fixture.initialize).not.toHaveBeenCalled();
+ expect(fixture.addEventListener).not.toHaveBeenCalled();
+ expect(fixture.console.debug).not.toHaveBeenCalled();
+});
+
+test('tracking binds once, forwards nested clicks and stays quiet on success', () => {
+ const fixture = analyticsFixture();
+ fixture.tracking();
+ expect(fixture.addEventListener).not.toHaveBeenCalled();
+ fixture.bootstrap();
+ fixture.tracking();
+ fixture.tracking();
+ expect(fixture.addEventListener).toHaveBeenCalledOnce();
+ const [event, listener] = fixture.addEventListener.mock.calls[0];
+ expect(event).toBe('click');
+ const link = {
+ tagName: 'A',
+ href: 'https://aspire.dev/docs/',
+ textContent: ' Docs ',
+ attributes: [{ name: 'data-track-source-name', value: 'header' }],
+ getAttribute: () => 'docs-link',
+ };
+ listener({ target: { closest: () => link } });
+ expect(fixture.capturePageAction).toHaveBeenCalledExactlyOnceWith(link, {
+ name: 'docs-link', sourceName: 'header', href: link.href, text: 'Docs',
+ });
+ expect(fixture.console.debug).not.toHaveBeenCalled();
+ expect(fixture.console.warn).not.toHaveBeenCalled();
+});
+
+test('initialization and capture failures remain visible', () => {
+ const initialization = analyticsFixture();
+ initialization.initialize.mockImplementation(() => { throw new Error('initialization failed'); });
+ initialization.bootstrap();
+ expect(initialization.console.warn).toHaveBeenCalledWith(
+ '[1ds] Failed to initialize Application Insights:', expect.any(Error),
+ );
+
+ const tracking = analyticsFixture();
+ tracking.bootstrap();
+ tracking.tracking();
+ tracking.capturePageAction.mockImplementation(() => { throw new Error('capture failed'); });
+ tracking.addEventListener.mock.calls[0][1]({
+ target: { closest: () => ({
+ tagName: 'BUTTON', textContent: '', attributes: [], getAttribute: () => 'button',
+ }) },
+ });
+ expect(tracking.console.warn).toHaveBeenCalledWith(
+ '[track] Failed to track event:', expect.any(Error),
+ );
+});
diff --git a/src/frontend/tests/unit/api-markdown.vitest.test.ts b/src/frontend/tests/unit/api-markdown.vitest.test.ts
index 159015258..5b32213c8 100644
--- a/src/frontend/tests/unit/api-markdown.vitest.test.ts
+++ b/src/frontend/tests/unit/api-markdown.vitest.test.ts
@@ -6,7 +6,13 @@
-- route module imports and test props are intentionally dynamic in this harness
*/
import { describe, expect, it, vi } from 'vitest';
+import { createMarkdownProcessor } from '@astrojs/markdown-remark';
+import { selectAll } from 'hast-util-select';
+import { toHtml } from 'hast-util-to-html';
+import rehypeParse from 'rehype-parse';
+import { unified } from 'unified';
+import { escapeTableCell } from '@utils/api-markdown-shared';
import {
renderCSharpDocMarkdown,
renderCSharpMemberKindMarkdown,
@@ -236,6 +242,92 @@ describe('API markdown routes', () => {
});
describe('API markdown helpers', () => {
+ const tableProcessor = createMarkdownProcessor({ smartypants: false, syntaxHighlight: false });
+
+ async function renderCell(value: string) {
+ const processor = await tableProcessor;
+ const result = await processor.render(
+ `| Value | Sentinel |\n| --- | --- |\n| ${escapeTableCell(value)} | intact |`
+ );
+ const tree = unified().use(rehypeParse, { fragment: true }).parse(result.code);
+ expect(selectAll('tbody tr', tree)).toHaveLength(1);
+ const cells = selectAll('td', tree);
+ expect(cells).toHaveLength(2);
+ expect(toHtml(cells[1])).toBe('| intact | ');
+ return toHtml(cells[0]);
+ }
+
+ it.each([0, 1, 2, 3, 4])('preserves %i literal backslashes before a pipe in a GFM cell', async (count) => {
+ const value = `left${'\\'.repeat(count)}|right`;
+ expect(await renderCell(value)).toBe(`${value} | `);
+ });
+
+ it('preserves ordinary inline code containing pipes', async () => {
+ expect(await renderCell('`left|middle|right`')).toBe('left|middle|right | ');
+ });
+
+ it.each(['\r\n', '\r', '\n'])('keeps %j line endings within a single table row', async (newline) => {
+ expect(await renderCell(`first${newline}second`)).toBe('first
second | ');
+ });
+
+ it('preserves links, emphasis, code spans and literal paths in rendered table cells', async () => {
+ expect(await renderCell(
+ '[API | docs](/reference/api/) **important** `C:\\src\\app` and C:\\src\\app\\'
+ )).toBe(
+ 'API | docs important '
+ + 'C:\\src\\app and C:\\src\\app\\ | '
+ );
+ });
+
+ it('encodes repeated prose backslashes and pipes once, without changing plain code spans', async () => {
+ const value = 'a\\|b\\\\|c | `C:\\src\\app` | `left|right`';
+ expect(escapeTableCell(value)).toBe(
+ 'a\\\\\\|b\\\\\\\\\\|c \\| `C:\\src\\app` \\| `left\\|right`'
+ );
+ expect(await renderCell(value)).toBe(
+ 'a\\|b\\\\|c | C:\\src\\app | left|right | '
+ );
+ });
+
+ it('preserves code backslashes when a pipe occurs elsewhere in the same span', async () => {
+ expect(await renderCell('before\r\n`C:\\src | D:\\data` after\\|end')).toBe(
+ 'before
C:\\src | D:\\data after\\|end | '
+ );
+ });
+
+ it('preserves existing Markdown escapes instead of treating the cell as raw text', async () => {
+ expect(await renderCell('\\*literal\\* and \\[label\\] | `C:\\src\\app`')).toBe(
+ '*literal* and [label] | C:\\src\\app | '
+ );
+ });
+
+ it('preserves inline-code link labels and single-line code from API renderers', async () => {
+ expect(await renderCell('[`left|right`](/reference/api/) and `first second`')).toBe(
+ 'left|right and first second | '
+ );
+ });
+
+ it('preserves rich Markdown from the C# documentation table renderer', async () => {
+ const markdown = renderCSharpDocMarkdown([{
+ kind: 'list',
+ style: 'table',
+ items: [{
+ term: [{ kind: 'text', text: 'path\\|name' }],
+ description: [
+ { kind: 'href', text: 'API | docs', value: '/reference/api/' },
+ { kind: 'code', text: '%LocalAppData%\\Aspire\\BrowserData' },
+ ],
+ }],
+ }], { allTypes: [], base: '', packageName: 'Test.Package' });
+ const result = await (await tableProcessor).render(markdown);
+ const tree = unified().use(rehypeParse, { fragment: true }).parse(result.code);
+ expect(selectAll('tbody tr', tree)).toHaveLength(1);
+ expect(selectAll('td', tree).map((node) => toHtml(node))).toEqual([
+ 'path\\|name | ',
+ 'API | docs %LocalAppData%\\Aspire\\BrowserData | ',
+ ]);
+ });
+
it('normalizes note blockquotes to a single level', () => {
const markdown = renderCSharpDocMarkdown(
[
diff --git a/src/frontend/tests/unit/api-search-lifecycle.vitest.test.ts b/src/frontend/tests/unit/api-search-lifecycle.vitest.test.ts
index 5fd4016bb..f02cf811e 100644
--- a/src/frontend/tests/unit/api-search-lifecycle.vitest.test.ts
+++ b/src/frontend/tests/unit/api-search-lifecycle.vitest.test.ts
@@ -4,6 +4,9 @@ import { dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { runInNewContext } from 'node:vm';
import { ModuleKind, ScriptTarget, transpileModule } from 'typescript';
+import { selectAll } from 'hast-util-select';
+import rehypeParse from 'rehype-parse';
+import { unified } from 'unified';
import { readApiSearchIndex, registerApiSearch } from '@components/api-reference/search-lifecycle';
import * as searchStats from '@utils/ts-api-search-stats';
@@ -18,6 +21,32 @@ const surfaces = [
type MountSearch = (root: HTMLElement, signal: AbortSignal) => void;
+function readControllerScript(source: string): string {
+ const tree = unified().use(rehypeParse, { fragment: true }).parse(source);
+ const scripts = selectAll('script', tree).filter((node) =>
+ !('src' in node.properties) && !('is:inline' in node.properties)
+ && (!node.properties.type || node.properties.type === 'module'));
+ expect(scripts).toHaveLength(1);
+ return scripts[0].children.map((node) => node.type === 'text' ? node.value : '').join('');
+}
+
+describe('Astro controller script extraction', () => {
+ it.each(['script', 'ScRiPt'])('parses %s boundaries and quoted attributes, not script-like tags', (tag) => {
+ expect(readControllerScript(`
+ not a controller
+
+
+
+ <${tag} data-label="a > b">const value = "&";
+ `)).toBe('const value = "&";');
+ });
+
+ it('rejects missing or ambiguous controllers', () => {
+ expect(() => readControllerScript('no')).toThrow();
+ expect(() => readControllerScript('')).toThrow();
+ });
+});
+
describe('API search navigation lifecycle', () => {
let events: EventTarget;
let roots: Map;
@@ -162,9 +191,14 @@ describe('API search navigation lifecycle', () => {
if (kind === 'type' || kind === 'item') segments.push(language === 'csharp' ? '[type]' : '[item]');
const filename = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..',
'src', 'pages', 'reference', 'api', ...segments, 'index.astro');
- const script = readFileSync(filename, 'utf8').match(/>', 'scriptnamescript'],
+ ['', 'section'],
+ ['<> & !!!', 'section'],
+ ])('allows only slug characters in plain text %j', (text, expected) => {
+ expect(slugifyHeading(text)).toBe(expected);
+ expect(slugifyHeading(text)).toMatch(/^[\p{Letter}\p{Number}-]+$/u);
+ });
+
+ it('preserves heading IDs when the caller extracts MDAST text before slugging', () => {
+ const text = headingPlainText([
+ { type: 'html', value: '' },
+ { type: 'text', value: 'Running ' },
+ { type: 'strong', children: [{ type: 'text', value: 'the ' }] },
+ { type: 'link', url: '/app/', children: [{ type: 'inlineCode', value: 'AppHost' }] },
+ { type: 'html', value: '' },
+ ]);
+ expect(text).toBe('Running the AppHost');
+ expect(slugifyHeading(text)).toBe('running-the-apphost');
+ });
});
describe('toSentenceCase', () => {
diff --git a/src/frontend/tests/unit/search.vitest.test.ts b/src/frontend/tests/unit/search.vitest.test.ts
new file mode 100644
index 000000000..b6af7b639
--- /dev/null
+++ b/src/frontend/tests/unit/search.vitest.test.ts
@@ -0,0 +1,108 @@
+import type { RootContent } from 'hast';
+import rehypeParse from 'rehype-parse';
+import { unified } from 'unified';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { SearchResponse } from '@scripts/search';
+
+const pagefind = vi.hoisted(() => ({ search: vi.fn() }));
+vi.mock('https://aspire.dev/pagefind/pagefind.js', () => pagefind);
+
+function textContent(node: RootContent): string {
+ if (node.type === 'text') return node.value;
+ return 'children' in node ? node.children.map(textContent).join('') : '';
+}
+
+describe('WebMCP search excerpts', () => {
+ const parse = unified().use(rehypeParse, { fragment: true });
+ const createElement = vi.fn((tag: string) => {
+ expect(tag).toBe('template');
+ // Model detached template content with a real HTML parser, not a tag regex.
+ const content = { textContent: '' };
+ return {
+ content,
+ set innerHTML(html: string) {
+ content.textContent = parse.parse(html).children.map(textContent).join('');
+ },
+ };
+ });
+
+ beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ vi.stubGlobal('window', { location: new URL('https://aspire.dev/') });
+ vi.stubGlobal('document', { createElement });
+ pagefind.search.mockResolvedValue({ results: [] });
+ });
+
+ afterEach(() => vi.unstubAllGlobals());
+
+ function hit(excerpt?: string, title?: string) {
+ return {
+ data: vi.fn().mockResolvedValue({ url: '/get-started/', meta: { title }, excerpt }),
+ };
+ }
+
+ it.each([
+ [' Aspire Redis & cache ', 'Aspire Redis & cache'],
+ ['match <T> | \', 'match | \\'],
+ ['beforenested match after', 'beforenested match after'],
+ ['x < y and unfinished', 'x < y and unfinished'],
+ ['
text',
+ 'globalThis.injected = truetext'],
+ ['<img src=x onerror="fail()">', ''],
+ [undefined, ''],
+ ])('extracts text from the inert HTML excerpt %j', async (excerpt, expected) => {
+ pagefind.search.mockResolvedValue({ results: [hit(excerpt, 'Getting started')] });
+ const { searchAspireDocs } = await import('@scripts/search');
+ expect(await searchAspireDocs(' redis ', 10)).toEqual({
+ results: [{ title: 'Getting started', url: '/get-started/', excerpt: expected }],
+ });
+ expect(pagefind.search).toHaveBeenCalledWith('redis');
+ expect(createElement).toHaveBeenCalledExactlyOnceWith('template');
+ });
+
+ it('preserves result limits, title fallback, and empty queries/results', async () => {
+ const hits = [hit('one'), hit('two'), hit('three')];
+ pagefind.search.mockResolvedValue({ results: hits });
+ const { searchAspireDocs } = await import('@scripts/search');
+ const response = await searchAspireDocs('redis', 2);
+ expect(response.results).toHaveLength(2);
+ expect(response.results[0].title).toBe('/get-started/');
+ expect(hits[2].data).not.toHaveBeenCalled();
+ expect((await searchAspireDocs('redis', 0)).results).toHaveLength(1);
+ pagefind.search.mockClear();
+ expect(await searchAspireDocs(' \n ', 10)).toEqual({ results: [] });
+ expect(pagefind.search).not.toHaveBeenCalled();
+ pagefind.search.mockResolvedValue({ results: [] });
+ expect(await searchAspireDocs('no matches', 10)).toEqual({ results: [] });
+ });
+
+ it('preserves the unavailable response without a browser environment', async () => {
+ vi.stubGlobal('window', undefined);
+ const { searchAspireDocs } = await import('@scripts/search');
+ expect(await searchAspireDocs('redis', 10)).toEqual({
+ results: [],
+ unavailable: true,
+ reason: 'Pagefind is not available in this environment.',
+ });
+ });
+
+ it('keeps decoded excerpts inside the unchanged WebMCP JSON-text envelope', async () => {
+ const registerTool = vi.fn<(tool: {
+ execute: (input: unknown) => Promise;
+ }) => void>();
+ vi.stubGlobal('navigator', { modelContext: { registerTool } });
+ const excerpt = ' & "quoted"';
+ pagefind.search.mockResolvedValue({
+ results: [hit('<img src=x onerror="fail()"> & "quoted"')],
+ });
+ await import('@scripts/webmcp');
+ const response: SearchResponse = {
+ results: [{ title: '/get-started/', url: '/get-started/', excerpt }],
+ };
+ expect(await registerTool.mock.calls[0][0].execute({ query: 'redis' })).toEqual({
+ content: [{ type: 'text', text: JSON.stringify(response) }],
+ isError: false,
+ });
+ });
+});
diff --git a/src/frontend/tests/unit/site-ui-runtime.vitest.test.ts b/src/frontend/tests/unit/site-ui-runtime.vitest.test.ts
new file mode 100644
index 000000000..34fd4b06a
--- /dev/null
+++ b/src/frontend/tests/unit/site-ui-runtime.vitest.test.ts
@@ -0,0 +1,564 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getEventListeners } from 'node:events';
+import { readFileSync } from 'node:fs';
+import { runInNewContext } from 'node:vm';
+import { ModuleKind, ScriptTarget, transpileModule } from 'typescript';
+import type { AsyncIconLoader } from 'mermaid';
+
+const mermaidSource = readFileSync(
+ new URL('../../src/scripts/mermaid.ts', import.meta.url),
+ 'utf8'
+);
+const scrollComponent = readFileSync(
+ new URL('../../src/components/ScrollToTop.astro', import.meta.url),
+ 'utf8'
+);
+const extractScript = (component: string) =>
+ component.match(/')).toBe('const ready = true;');
+});
+
+class Element extends EventTarget {
+ id = '';
+ lang = 'en';
+ type = '';
+ ariaLabel = '';
+ textContent = '';
+ innerHTML = '';
+ scrollHeight = 2000;
+ style: Record = {};
+ attributes = new Map();
+ dataset: Record = {};
+ classes = new Set();
+ classList = {
+ add: (...names: string[]) => names.forEach((name) => this.classes.add(name)),
+ remove: (...names: string[]) => names.forEach((name) => this.classes.delete(name)),
+ contains: (name: string) => this.classes.has(name),
+ toggle: (name: string, force = !this.classes.has(name)) => {
+ if (force) this.classes.add(name);
+ else this.classes.delete(name);
+ return force;
+ },
+ };
+ parentNode: Element | null = null;
+ children: Element[] = [];
+ root = false;
+ constructor(readonly tagName = 'div') {
+ super();
+ }
+ get parentElement() {
+ return this.parentNode;
+ }
+ get isConnected(): boolean {
+ return this.root || Boolean(this.parentNode?.isConnected);
+ }
+ setAttribute(name: string, value: string) {
+ this.attributes.set(name, value);
+ if (name.startsWith('data-')) this.dataset[name.slice(5)] = value;
+ }
+ getAttribute(name: string) {
+ return name.startsWith('data-')
+ ? (this.dataset[name.slice(5)] ?? null)
+ : (this.attributes.get(name) ?? null);
+ }
+ hasAttribute(name: string) {
+ return this.getAttribute(name) !== null;
+ }
+ removeAttribute(name: string) {
+ this.attributes.delete(name);
+ if (name.startsWith('data-')) delete this.dataset[name.slice(5)];
+ }
+ append(child: Element) {
+ child.remove();
+ this.appendChild(child);
+ }
+ appendChild(child: T) {
+ child.parentNode = this;
+ this.children.push(child);
+ return child;
+ }
+ removeChild(child: Element) {
+ this.children = this.children.filter((element) => element !== child);
+ child.parentNode = null;
+ }
+ remove() {
+ this.parentNode?.removeChild(this);
+ }
+ contains(element: Element): boolean {
+ return this === element || this.children.some((child) => child.contains(element));
+ }
+ all(): Element[] {
+ return this.children.flatMap((child) => [child, ...child.all()]);
+ }
+ querySelectorAll(selector: string) {
+ return this.all().filter((element) => {
+ if (selector.startsWith('#')) return element.id === selector.slice(1);
+ if (selector === 'pre.mermaid') {
+ return element.tagName === 'pre' && element.classList.contains('mermaid');
+ }
+ if (selector.startsWith('.')) return element.classList.contains(selector.slice(1));
+ return element.tagName === selector;
+ });
+ }
+ querySelector(selector: string): Element | null {
+ return this.querySelectorAll(selector)[0] ?? null;
+ }
+}
+
+class Document extends EventTarget {
+ documentElement = new Element('html');
+ head = this.documentElement.appendChild(new Element('head'));
+ body = this.documentElement.appendChild(new Element('body'));
+ readyState = 'complete';
+ constructor() {
+ super();
+ this.documentElement.root = true;
+ this.documentElement.setAttribute('data-theme', 'light');
+ }
+ createElement(tag: string) {
+ return new Element(tag);
+ }
+ querySelectorAll(selector: string) {
+ return this.documentElement.querySelectorAll(selector);
+ }
+ querySelector(selector: string) {
+ return this.documentElement.querySelector(selector);
+ }
+ getElementById(id: string) {
+ return this.querySelector(`#${id}`);
+ }
+ emit(name: string) {
+ this.dispatchEvent(new Event(name));
+ }
+ replaceBody(sources: string[] = []) {
+ this.body.remove();
+ this.body = this.documentElement.appendChild(new Element('body'));
+ return sources.map((source) => {
+ const diagram = this.body.appendChild(new Element('pre'));
+ diagram.classList.add('mermaid');
+ diagram.textContent = source;
+ return diagram;
+ });
+ }
+}
+
+function observers() {
+ const instances: Observer[] = [];
+ class Observer {
+ targets = new Set();
+ constructor(readonly callback: () => void) {
+ instances.push(this);
+ }
+ observe(target: Element) {
+ this.targets.add(target);
+ }
+ disconnect() {
+ this.targets.clear();
+ }
+ }
+ return {
+ Observer,
+ instances,
+ notify: (target: Element) => {
+ instances
+ .filter((observer) => observer.targets.has(target))
+ .forEach((observer) => observer.callback());
+ },
+ };
+}
+
+function deferred() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise((yes, no) => {
+ resolve = yes;
+ reject = no;
+ });
+ return { promise, resolve, reject };
+}
+
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+async function mermaidRuntime({
+ sources = ['graph TD; A-->B', 'graph TD; C-->D'],
+ loading = false,
+} = {}) {
+ const { iconPacks } = await import('../../config/icon-packs.mjs');
+ const icons = { prefix: 'test', icons: { app: { body: '' } } };
+ const fetch = vi
+ .fn()
+ .mockImplementation(() => Promise.resolve(new Response(JSON.stringify(icons))));
+ const document = new Document();
+ const diagrams = document.replaceBody(sources);
+ if (loading) document.readyState = 'loading';
+ const mutation = observers();
+ const logger = { log: vi.fn(), error: vi.fn() };
+ const mermaid = {
+ initialize: vi.fn<(config: { theme: string }) => void>(),
+ registerIconPacks: vi.fn<(packs: AsyncIconLoader[]) => void>(),
+ render: vi
+ .fn<(id: string, source: string) => Promise<{ svg: string }>>()
+ .mockImplementation((_id, source) => Promise.resolve({ svg: `` })),
+ };
+ const imported = deferred<{ default: typeof mermaid }>();
+ const importMermaid = vi.fn(() => imported.promise);
+ // Replace only the module boundary; execute the actual site runtime.
+ runInNewContext(compile(mermaidSource).replace("import('mermaid')", 'importMermaid()'), {
+ document,
+ MutationObserver: mutation.Observer,
+ console: logger,
+ queueMicrotask,
+ importMermaid,
+ iconPacks,
+ fetch,
+ Error,
+ });
+ if (!loading) document.emit('astro:page-load');
+ return {
+ document,
+ diagrams,
+ mutation,
+ mermaid,
+ imported,
+ importMermaid,
+ logger,
+ icons,
+ iconPacks,
+ fetch,
+ theme(value: string, target = document.documentElement) {
+ target.setAttribute('data-theme', value);
+ mutation.notify(target);
+ },
+ swap(sources: string[]) {
+ document.emit('astro:before-swap');
+ const diagrams = document.replaceBody(sources);
+ document.emit('astro:after-swap');
+ document.emit('astro:page-load');
+ return diagrams;
+ },
+ };
+}
+
+describe('site-owned Mermaid runtime', () => {
+ it('coalesces readiness, page-load and same-theme notifications before and during rendering', async () => {
+ const fixture = await mermaidRuntime({ loading: true });
+ const { document, mermaid, imported, diagrams, importMermaid, logger } = fixture;
+ expect(importMermaid).not.toHaveBeenCalled();
+ document.emit('DOMContentLoaded');
+ document.emit('astro:page-load');
+ fixture.theme('light');
+ await flush();
+ expect(importMermaid).toHaveBeenCalledOnce();
+ const render = deferred<{ svg: string }>();
+ mermaid.render.mockReturnValueOnce(render.promise);
+ imported.resolve({ default: mermaid });
+ await flush();
+ document.emit('astro:after-swap');
+ document.emit('astro:page-load');
+ fixture.theme('light');
+ await flush();
+ expect(mermaid.render).toHaveBeenCalledOnce();
+ render.resolve({ svg: '' });
+ await flush();
+ expect(mermaid.render).toHaveBeenCalledTimes(2);
+ expect(mermaid.initialize).toHaveBeenCalledTimes(1);
+ expect(diagrams.map((diagram) => diagram.getAttribute('data-processed'))).toEqual([
+ 'true',
+ 'true',
+ ]);
+ expect(mermaid.registerIconPacks).toHaveBeenCalledOnce();
+ expect(mermaid.registerIconPacks.mock.calls[0][0].map((pack) => pack.name)).toEqual(
+ fixture.iconPacks.map((pack) => pack.name)
+ );
+ expect(logger.log).not.toHaveBeenCalled();
+ expect(logger.error).not.toHaveBeenCalled();
+ });
+
+ it('keeps imports lazy on empty pages and renders two diagrams once on each return visit', async () => {
+ const fixture = await mermaidRuntime({ sources: [] });
+ await flush();
+ expect(fixture.importMermaid).not.toHaveBeenCalled();
+ fixture.imported.resolve({ default: fixture.mermaid });
+ for (let visit = 1; visit <= 3; visit++) {
+ fixture.swap(['graph TD; A-->B', 'graph TD; C-->D']);
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(visit * 2);
+ fixture.swap([]);
+ await flush();
+ }
+ expect(fixture.importMermaid).toHaveBeenCalledOnce();
+ });
+
+ it('ignores equivalent attribute churn and rerenders only for effective theme changes', async () => {
+ const fixture = await mermaidRuntime();
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ fixture.document.documentElement.removeAttribute('data-theme');
+ fixture.theme('light');
+ fixture.theme('dark', fixture.document.body);
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(2);
+ fixture.theme('dark');
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(4);
+ expect(fixture.mermaid.initialize.mock.calls.map(([config]) => config.theme)).toEqual([
+ 'default',
+ 'dark',
+ ]);
+ expect(fixture.mermaid.render.mock.calls.map(([, source]) => source)).toEqual([
+ 'graph TD; A-->B',
+ 'graph TD; C-->D',
+ 'graph TD; A-->B',
+ 'graph TD; C-->D',
+ ]);
+ });
+
+ it('serializes global theme configuration and discards superseded in-flight SVGs', async () => {
+ const fixture = await mermaidRuntime({ sources: ['graph TD; A-->B'] });
+ const render = deferred<{ svg: string }>();
+ fixture.mermaid.render.mockReturnValueOnce(render.promise);
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ fixture.theme('dark');
+ fixture.theme('light');
+ fixture.theme('dark');
+ await flush();
+ expect(fixture.mermaid.initialize).toHaveBeenCalledOnce();
+ expect(fixture.mermaid.render).toHaveBeenCalledOnce();
+ const latest = deferred<{ svg: string }>();
+ fixture.mermaid.render.mockReturnValueOnce(latest.promise);
+ render.resolve({ svg: '' });
+ await flush();
+ expect(fixture.diagrams[0].innerHTML).toBe('');
+ expect(fixture.mermaid.initialize.mock.calls.map(([config]) => config.theme)).toEqual([
+ 'default',
+ 'dark',
+ ]);
+ latest.resolve({ svg: '' });
+ await flush();
+ expect(fixture.diagrams[0].innerHTML).toBe('');
+ });
+
+ it('abandons imports owned by a replaced page and observes the new body, not the old body', async () => {
+ const fixture = await mermaidRuntime();
+ await flush();
+ const oldBody = fixture.document.body;
+ const next = fixture.swap(['graph TD; New-->Page']);
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledExactlyOnceWith(
+ expect.any(String),
+ 'graph TD; New-->Page'
+ );
+ expect(fixture.diagrams.every((diagram) => diagram.innerHTML === '')).toBe(true);
+ expect(fixture.mutation.instances[0].targets.has(oldBody)).toBe(false);
+ fixture.theme('dark');
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(2);
+ expect(next[0].getAttribute('data-processed')).toBe('true');
+ });
+
+ it.each(['resolve', 'reject'] as const)(
+ 'does not write stale %s completions after a swap',
+ async (outcome) => {
+ const fixture = await mermaidRuntime();
+ const render = deferred<{ svg: string }>();
+ fixture.mermaid.render.mockReturnValueOnce(render.promise);
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ const next = fixture.swap(['graph TD; New-->Page']);
+ await flush();
+ expect(fixture.mermaid.initialize).toHaveBeenCalledOnce();
+ if (outcome === 'resolve') render.resolve({ svg: '' });
+ else render.reject(new Error('obsolete render failed'));
+ await flush();
+ expect(fixture.diagrams[0].innerHTML).toBe('');
+ expect(fixture.diagrams[0].children).toHaveLength(0);
+ expect(fixture.diagrams[0].hasAttribute('data-processed')).toBe(false);
+ expect(next[0].innerHTML).toContain('New-->Page');
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(2);
+ expect(fixture.logger.error).toHaveBeenCalledTimes(outcome === 'reject' ? 1 : 0);
+ }
+ );
+
+ it('keeps current work alive when navigation preparation is canceled', async () => {
+ const fixture = await mermaidRuntime();
+ fixture.document.emit('astro:before-preparation');
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(2);
+ fixture.theme('dark');
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(4);
+ });
+
+ it('preserves visible escaped errors and source without retrying an unchanged failed diagram', async () => {
+ const fixture = await mermaidRuntime({ sources: ['invalid '] });
+ fixture.mermaid.render.mockRejectedValueOnce(new Error(''));
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ const [diagram] = fixture.diagrams;
+ expect(fixture.logger.error).toHaveBeenCalledOnce();
+ expect(diagram.getAttribute('data-diagram')).toBe('invalid ');
+ expect(diagram.textContent).toBe('Unable to render diagram: ');
+ expect(diagram.classList.contains('mermaid-error')).toBe(true);
+ expect(diagram.innerHTML).toBe('');
+ fixture.document.emit('astro:page-load');
+ await flush();
+ expect(fixture.mermaid.render).toHaveBeenCalledOnce();
+ fixture.theme('dark');
+ await flush();
+ expect(fixture.mermaid.render.mock.calls[1][1]).toBe('invalid ');
+ });
+
+ it('logs import failures, clears the failed import promise and retries on the next page load', async () => {
+ const fixture = await mermaidRuntime();
+ fixture.imported.reject(new Error('import failed'));
+ await flush();
+ expect(fixture.logger.error).toHaveBeenCalled();
+ fixture.importMermaid.mockResolvedValueOnce({ default: fixture.mermaid });
+ fixture.document.emit('astro:page-load');
+ await flush();
+ expect(fixture.importMermaid).toHaveBeenCalledTimes(2);
+ expect(fixture.mermaid.render).toHaveBeenCalledTimes(2);
+ });
+
+ it('loads configured icon packs lazily and reports failed responses', async () => {
+ const fixture = await mermaidRuntime();
+ fixture.imported.resolve({ default: fixture.mermaid });
+ await flush();
+ expect(fixture.fetch).not.toHaveBeenCalled();
+ const pack = fixture.mermaid.registerIconPacks.mock.calls[0][0][0];
+ await expect(pack.loader()).resolves.toEqual(fixture.icons);
+ expect(fixture.fetch).toHaveBeenCalledWith(fixture.iconPacks[0].url);
+ fixture.fetch.mockResolvedValueOnce(new Response('', { status: 503 }));
+ await expect(pack.loader()).rejects.toThrow('HTTP 503');
+ });
+});
+
+function scrollRuntime({ reducedMotion = false } = {}) {
+ vi.useFakeTimers();
+ const document = new Document();
+ const window = Object.assign(new EventTarget(), {
+ scrollY: 500,
+ innerHeight: 900,
+ innerWidth: 1440,
+ outerWidth: 1440,
+ scrollTo: vi.fn(),
+ matchMedia: () => ({ matches: reducedMotion }),
+ requestAnimationFrame: (callback: () => void) => setTimeout(callback, 16),
+ cancelAnimationFrame: clearTimeout,
+ });
+ type ScrollElement = Element & { connectedCallback(): void; disconnectedCallback(): void };
+ let Constructor: (new () => ScrollElement) | undefined;
+ runInNewContext(compile(scrollSource!), {
+ document,
+ window,
+ HTMLElement: Element,
+ AbortController,
+ customElements: {
+ define: (_name: string, value: new () => ScrollElement) => {
+ Constructor = value;
+ },
+ },
+ });
+ if (!Constructor) throw new Error('Scroll-to-top custom element was not registered.');
+ const root = document.body.appendChild(new Constructor());
+ const button = root.appendChild(new Element('button'));
+ button.id = 'scroll-to-top-button';
+ button.type = 'button';
+ root.connectedCallback();
+ return { document, window, root, button: () => button };
+}
+
+describe('site-owned scroll-to-top control', () => {
+ afterEach(() => vi.useRealTimers());
+
+ it('mounts once per connection without document readiness or keyboard handlers', () => {
+ const fixture = scrollRuntime();
+ fixture.root.connectedCallback();
+ fixture.document.emit('DOMContentLoaded');
+ fixture.document.emit('astro:page-load');
+ expect(vi.getTimerCount()).toBe(1);
+ vi.runAllTimers();
+ const button = fixture.button();
+ fixture.document.emit('astro:page-load');
+ vi.runAllTimers();
+ expect(fixture.button()).toBe(button);
+ expect(fixture.document.querySelectorAll('#scroll-to-top-button')).toHaveLength(1);
+ expect(getEventListeners(fixture.document, 'keydown')).toHaveLength(0);
+ expect(getEventListeners(fixture.document, 'DOMContentLoaded')).toHaveLength(0);
+ });
+
+ it.each([false, true])(
+ 'uses only native click activation (reduced motion: %s)',
+ (reducedMotion) => {
+ const fixture = scrollRuntime({ reducedMotion });
+ vi.runAllTimers();
+ const button = fixture.button();
+ expect(button.type).toBe('button');
+ for (const name of ['touchstart', 'touchend', 'keydown']) {
+ expect(getEventListeners(button, name)).toHaveLength(0);
+ }
+ const click = new Event('click', { cancelable: true });
+ button.dispatchEvent(click);
+ expect(click.defaultPrevented).toBe(false);
+ expect(fixture.window.scrollTo).toHaveBeenCalledExactlyOnceWith({
+ top: 0,
+ behavior: reducedMotion ? 'auto' : 'smooth',
+ });
+ expect(scrollComponent).toContain('button:focus-visible');
+ }
+ );
+
+ it('disposes element/window handlers and pending frames when disconnected', () => {
+ const fixture = scrollRuntime();
+ fixture.root.disconnectedCallback();
+ expect(vi.getTimerCount()).toBe(0);
+ vi.runAllTimers();
+ for (let visit = 0; visit < 3; visit++) {
+ fixture.root.connectedCallback();
+ vi.runAllTimers();
+ expect(getEventListeners(fixture.document, 'keydown')).toHaveLength(0);
+ expect(getEventListeners(fixture.window, 'scroll')).toHaveLength(1);
+ fixture.window.dispatchEvent(new Event('scroll'));
+ expect(vi.getTimerCount()).toBe(1);
+ fixture.root.disconnectedCallback();
+ expect(vi.getTimerCount()).toBe(0);
+ expect(getEventListeners(fixture.document, 'keydown')).toHaveLength(0);
+ expect(getEventListeners(fixture.window, 'scroll')).toHaveLength(0);
+ expect(getEventListeners(fixture.window, 'resize')).toHaveLength(0);
+ expect(getEventListeners(fixture.button(), 'click')).toHaveLength(0);
+ }
+ });
+
+ it('survives canceled preparation and updates scroll/zoom visibility in one frame', () => {
+ const fixture = scrollRuntime();
+ vi.runAllTimers();
+ const button = fixture.button();
+ fixture.document.emit('astro:before-preparation');
+ expect(fixture.button()).toBe(button);
+ expect(getEventListeners(fixture.document, 'keydown')).toHaveLength(0);
+ fixture.window.outerWidth = 6000;
+ fixture.window.dispatchEvent(new Event('resize'));
+ vi.runAllTimers();
+ expect(button.classList.contains('visible')).toBe(false);
+ fixture.window.outerWidth = 1440;
+ fixture.window.dispatchEvent(new Event('resize'));
+ vi.runAllTimers();
+ expect(button.classList.contains('visible')).toBe(true);
+ fixture.window.dispatchEvent(new Event('scroll'));
+ fixture.window.scrollY = 0;
+ fixture.window.dispatchEvent(new Event('scroll'));
+ vi.runAllTimers();
+ expect(button.classList.contains('visible')).toBe(false);
+ });
+});
diff --git a/src/frontend/tests/unit/update-integrations.vitest.test.ts b/src/frontend/tests/unit/update-integrations.vitest.test.ts
index e53478e95..6ef2b88a0 100644
--- a/src/frontend/tests/unit/update-integrations.vitest.test.ts
+++ b/src/frontend/tests/unit/update-integrations.vitest.test.ts
@@ -33,6 +33,15 @@ function docsPageExists(
);
}
+describe('integration catalog integrity', () => {
+ test('contains each NuGet package ID only once, ignoring case', () => {
+ const packageIds = aspireIntegrations.map(({ title }) => title.toLowerCase());
+ const duplicateIds = packageIds.filter((id, index) => packageIds.indexOf(id) !== index);
+
+ expect(duplicateIds).toEqual([]);
+ });
+});
+
describe('update-integrations icon handling', () => {
test('uses the package version for official Aspire packages from nuget.org', () => {
expect(
diff --git a/src/statichost/StaticHost/Live/LiveEndpoints.cs b/src/statichost/StaticHost/Live/LiveEndpoints.cs
index 96d88de12..98a0ac86c 100644
--- a/src/statichost/StaticHost/Live/LiveEndpoints.cs
+++ b/src/statichost/StaticHost/Live/LiveEndpoints.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json.Serialization;
@@ -203,7 +204,8 @@ private static async Task TwitchWebhook(
// replayed indefinitely.
if (!TwitchWebhookHandler.IsFresh(timestamp, time.GetUtcNow(), TimeSpan.FromMinutes(10)))
{
- logger.LogWarning("Twitch webhook timestamp {Timestamp} is stale or unparseable; rejecting.", timestamp);
+ logger.LogWarning("Twitch webhook timestamp {Timestamp} (sanitized) is stale or unparseable; rejecting.",
+ TwitchWebhookHandler.SanitizeDiagnosticValue(timestamp));
return Results.Unauthorized();
}
@@ -226,15 +228,16 @@ private static async Task TwitchWebhook(
if (acquisition.Status == TwitchMessageAcquisitionStatus.Completed)
{
- logger.LogDebug("Twitch webhook replay ignored for {MessageId}.", messageId);
+ logger.LogDebug("Twitch webhook replay ignored for message {MessageId}.",
+ TwitchWebhookHandler.SanitizeDiagnosticValue(messageId));
return Results.Ok();
}
if (acquisition.Status == TwitchMessageAcquisitionStatus.Processing)
{
logger.LogDebug(
- "Twitch webhook {MessageId} is already being processed; asking Twitch to retry.",
- messageId);
+ "Twitch webhook message {MessageId} is already being processed; asking Twitch to retry.",
+ TwitchWebhookHandler.SanitizeDiagnosticValue(messageId));
return Results.StatusCode(StatusCodes.Status503ServiceUnavailable);
}
@@ -276,6 +279,7 @@ private static async Task TwitchWebhook(
private static async Task YouTubeVerify(
HttpContext context,
IYouTubeWebSubSubscriptionState subscriptions,
+ IOptions options,
TimeProvider time,
ILoggerFactory loggerFactory)
{
@@ -291,6 +295,19 @@ private static async Task YouTubeVerify(
var verifyToken = query["hub.verify_token"].ToString();
var logger = loggerFactory.CreateLogger("StaticHost.Live.YouTube.WebSub");
+ if (string.Equals(mode, "denied", StringComparison.Ordinal))
+ {
+ var channelId = options.Value.YouTube.ChannelId;
+ bool? matchesConfiguredTopic = string.IsNullOrEmpty(channelId)
+ ? null
+ : string.Equals(topic, YouTubeWebSubSubscriptionTransitions.TopicFor(channelId), StringComparison.Ordinal);
+ YouTubeDiagnostics.LogUntrustedDenial(
+ logger, query["hub.reason"].ToString(), !string.IsNullOrEmpty(topic), matchesConfiguredTopic);
+ return string.IsNullOrEmpty(topic)
+ ? Results.BadRequest("Invalid WebSub denial report.")
+ : Results.Ok();
+ }
+
if (!int.TryParse(query["hub.lease_seconds"], out var leaseSeconds) ||
string.IsNullOrEmpty(challenge))
{
@@ -304,7 +321,8 @@ private static async Task YouTubeVerify(
verifyToken,
leaseSeconds))
{
- logger.LogWarning("Rejected malformed YouTube WebSub {Mode} verification for {Topic}.", mode, topic);
+ LogRejectedVerification(
+ logger, mode, topic, options.Value.YouTube.ChannelId, malformed: true);
return Results.NotFound();
}
@@ -330,15 +348,36 @@ private static async Task YouTubeVerify(
if (!confirmed)
{
- logger.LogWarning("Rejected unexpected YouTube WebSub {Mode} verification for {Topic}.", mode, topic);
+ LogRejectedVerification(
+ logger, mode, topic, options.Value.YouTube.ChannelId, malformed: false);
return Results.NotFound();
}
- logger.LogInformation("YouTube WebSub subscription verified for {Topic}; granted lease {LeaseSeconds}s.",
- topic, leaseSeconds);
+ logger.LogInformation(
+ "YouTube {Operation} acknowledged; callback lease {LeaseSeconds}s. A matching retry does not extend the lease or reset subscription backoff.",
+ "WebSubVerification", leaseSeconds);
return Results.Text(challenge, "text/plain");
}
+ private static void LogRejectedVerification(
+ ILogger logger, string mode, string topic, string channelId, bool malformed)
+ {
+ var modeClassification = mode switch
+ {
+ "subscribe" => "Subscribe",
+ "unsubscribe" => "Unsubscribe",
+ _ => "Unknown",
+ };
+ bool? matchesConfiguredTopic = string.IsNullOrEmpty(channelId)
+ ? null
+ : string.Equals(topic, YouTubeWebSubSubscriptionTransitions.TopicFor(channelId), StringComparison.Ordinal);
+ logger.LogWarning(
+ "YouTube {Operation} rejected: {RejectionReason}; mode {ModeClassification}, " +
+ "topic present {TopicPresent}, matches configured topic {MatchesConfiguredTopic}.",
+ "WebSubVerification", malformed ? "Malformed" : "Unexpected", modeClassification,
+ !string.IsNullOrEmpty(topic), matchesConfiguredTopic);
+ }
+
private static async Task YouTubeWebhook(
HttpContext context,
IOptions options,
@@ -365,8 +404,8 @@ private static async Task YouTubeWebhook(
var signature = context.Request.Headers["X-Hub-Signature"].ToString();
if (!YouTubeWebhookHandler.IsValidSignature(youtube.WebhookSecret, bodyBytes, signature))
{
- logger.LogWarning("YouTube WebSub signature mismatch.");
- return Results.Unauthorized();
+ logger.LogWarning("YouTube WebSub signature missing or invalid; acknowledging and discarding the notification without processing.");
+ return Results.Ok();
}
if (env.IsDevelopment() && options.Value.EnableDevEndpoint && !youtube.IsConfigured)
@@ -408,16 +447,21 @@ internal static async Task ConfirmYouTubeLiveStatusAsync(
var channelId = youtube.ChannelId;
if (string.IsNullOrWhiteSpace(channelId))
{
- channelId = await ytClient.ResolveChannelIdAsync(youtube.ChannelHandle, cancellationToken).ConfigureAwait(false);
+ channelId = await ConfirmOperationAsync("NotificationChannelResolution", YouTubeDiagnostics.ChannelsEndpoint,
+ () => ytClient.ResolveChannelIdAsync(youtube.ChannelHandle, cancellationToken)).ConfigureAwait(false);
}
if (string.IsNullOrWhiteSpace(channelId))
{
- logger.LogWarning("Could not resolve YouTube channel id for webhook confirmation.");
+ logger.LogWarning("YouTube {Operation} returned no channel; notification confirmation is unavailable, not confirmed offline.",
+ "NotificationChannelResolution");
return;
}
- var live = await ytClient.GetCurrentLiveAsync(channelId, cancellationToken).ConfigureAwait(false);
+ var live = await ConfirmOperationAsync("NotificationConfirmation", YouTubeDiagnostics.SearchEndpoint,
+ () => ytClient.GetCurrentLiveAsync(channelId, cancellationToken)).ConfigureAwait(false);
+ logger.LogInformation("YouTube {Operation} succeeded at {CheckedAt}; observed live {ObservedLive}.",
+ "NotificationConfirmation", DateTimeOffset.UtcNow, live.Live);
await broadcaster.UpdateAsync(
new LiveStatusUpdate
{
@@ -428,6 +472,22 @@ await broadcaster.UpdateAsync(
youtube.OfflineConfirmationCount),
},
cancellationToken).ConfigureAwait(false);
+
+ async Task ConfirmOperationAsync(string operation, string endpoint, Func> action)
+ {
+ var started = Stopwatch.GetTimestamp();
+ try
+ {
+ return await action().ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+ catch (Exception exception)
+ {
+ YouTubeDiagnostics.LogFailure(logger, exception, operation, endpoint,
+ elapsedMs: Stopwatch.GetElapsedTime(started).TotalMilliseconds);
+ throw;
+ }
+ }
}
// --- Dev-only -----------------------------------------------------------
diff --git a/src/statichost/StaticHost/Live/LiveStatusOptions.cs b/src/statichost/StaticHost/Live/LiveStatusOptions.cs
index 381ffe530..adb9868f1 100644
--- a/src/statichost/StaticHost/Live/LiveStatusOptions.cs
+++ b/src/statichost/StaticHost/Live/LiveStatusOptions.cs
@@ -109,9 +109,9 @@ public sealed class YouTubeOptions
public int PollingIntervalSeconds { get; set; } = 120;
///
- /// How often to run the quota-expensive search.list discovery request
- /// while offline. Defaults to 30 minutes, which stays below the standard
- /// YouTube Data API daily quota.
+ /// How often to run search.list discovery while offline.
+ /// Defaults to 30 minutes; this limits scheduled searches, but does not
+ /// enforce the project's daily Search Queries quota across all callers.
///
[Range(30 * 60, 24 * 60 * 60)]
public int DiscoveryPollingIntervalSeconds { get; set; } = 30 * 60;
diff --git a/src/statichost/StaticHost/Live/LiveStatusServiceCollectionExtensions.cs b/src/statichost/StaticHost/Live/LiveStatusServiceCollectionExtensions.cs
index cbfb9fc95..751f5345c 100644
--- a/src/statichost/StaticHost/Live/LiveStatusServiceCollectionExtensions.cs
+++ b/src/statichost/StaticHost/Live/LiveStatusServiceCollectionExtensions.cs
@@ -47,11 +47,16 @@ public static TBuilder AddLiveStatus(this TBuilder builder)
.AddStandardResilienceHandler();
builder.Services.AddHttpClient(TwitchAppTokenProvider.HttpClientName)
.AddStandardResilienceHandler();
- builder.Services.AddHttpClient(YouTubeClient.HttpClientName)
+ builder.Services.AddHttpClient(YouTubeClient.HttpClientName,
+ client => client.MaxResponseContentBufferSize = YouTubeClient.ResponseBufferLimit)
.AddStandardResilienceHandler();
// Subscription POST retries are scheduled in Redis, not inside the HTTP request.
builder.Services.AddHttpClient(YouTubeClient.PubSubHttpClientName,
- client => client.Timeout = TimeSpan.FromSeconds(30));
+ client =>
+ {
+ client.Timeout = TimeSpan.FromSeconds(30);
+ client.MaxResponseContentBufferSize = YouTubeClient.ResponseBufferLimit;
+ });
builder.Services.AddSingleton();
builder.Services.AddSingleton();
diff --git a/src/statichost/StaticHost/Live/README.md b/src/statichost/StaticHost/Live/README.md
index d4ed37d3f..345c60124 100644
--- a/src/statichost/StaticHost/Live/README.md
+++ b/src/statichost/StaticHost/Live/README.md
@@ -51,18 +51,160 @@ restart the retry sequence. Successful verification resets the backoff;
acceptance of the subscription POST alone does not. A channel change starts a
fresh sequence.
-Each failed attempt logs one concise warning for expected HTTP errors or
-timeouts, including the failure count and next retry deadline. Exception
-details and hub error response bodies are available at Debug; unexpected
-exceptions remain Error-level with their stack traces. Successful verification
-is logged at Information. Shutdown or leadership cancellation does not count
-as an upstream failure.
+Each failed attempt logs one warning for expected HTTP errors or timeouts,
+including the failure count and next retry deadline. Unexpected failures are
+Error-level, with a bounded `SafeStackTrace` rendered from stack frames alone,
+without exception messages, argument values, or source file paths. Expected
+HTTP and timeout warnings omit stack traces. Diagnostics intentionally omit
+raw exception messages, URLs with query strings, and response bodies, which
+can contain credentials. HTTP acceptance is logged separately from successful callback
+verification: only verification establishes or renews the lease and resets
+backoff. Shutdown or leadership cancellation does not count as an upstream
+failure.
The live and idle polling intervals remain unchanged during subscription
backoff. Google documents feed notifications for uploads and video
title/description updates, not guaranteed broadcast start/stop events, so
fallback polling is still necessary.
+### YouTube operational diagnostics
+
+In the Aspire dashboard, open **Structured logs**, select the `aspiredev`
+resource, and filter for `YouTube` (the `StaticHost.Live.YouTube` categories).
+Information, Warning, and Error events are sufficient; enabling Debug or
+logging HTTP request bodies is not required.
+
+| `Operation` | Meaning |
+| --- | --- |
+| `ChannelResolution` | Resolve the configured handle through `channels.list`. A missing channel means detection is unavailable, not offline. |
+| `OfflineDiscovery` | Interval-limited `search.list` check for a broadcast while no live video is known; not a daily quota guard. |
+| `KnownVideoStatus` | Low-cost `videos.list` check of the currently known live video. |
+| `WebSubSubscribe` | Subscription POST accepted or failed; acceptance does **not** prove callback verification. |
+| `WebSubVerification` | A matching callback was acknowledged, with its `LeaseSeconds`; matching retries do not extend the original lease or reset backoff. |
+| `WebSubDenialReport` | An untrusted, unauthenticated `hub.mode=denied` report; not proof that Google denied a subscription. No state or polling changes. |
+| `NotificationChannelResolution` / `NotificationConfirmation` | Resolve the channel or run the confirming search after a signed notification. |
+| `BackgroundTick` | A failure outside the provider calls, such as state coordination. |
+
+Failed provider operations include the query-free outbound `Endpoint`,
+`ElapsedMs` measured with a monotonic clock, numeric `StatusCode`,
+standard `StatusReason` (not an untrusted reason phrase), `FailureType`,
+`IsTimeout`, `HttpRequestError`, `SocketError`, and `InnerFailureType` where
+available. Google JSON errors add bounded `ProviderReason` and `ProviderDomain`
+codes, for example `quotaExceeded` / `youtube.quota` or `accessNotConfigured` /
+`usageLimits`. These distinguish quota exhaustion from API configuration,
+network, and hub failures.
+
+The duration covers the client operation, including any existing Data API
+resilience retries and response parsing, but not the later Redis backoff write.
+For example, `WebSubSubscribe` with endpoint
+`pubsubhubbub.appspot.com/subscribe` and status 503 identifies an outbound hub
+failure, not an inbound website 503. Duration and status alone cannot establish
+the underlying provider cause.
+
+HTTP acceptance is logged before recording the sent request in Redis, so a
+subsequent persistence failure does not hide the provider's successful response.
+
+`ProviderDetail` contains only a fixed classification, such as temporary
+unavailability, transient error, invalid topic, or callback verification failure. Unknown or
+malformed bodies are omitted; `BodyTruncated` indicates the diagnostic read
+exceeded 4,096 characters. No raw HTML, provider message, API key, webhook
+secret, verification token, authorization header, or subscription form is
+logged by these diagnostics. Subscription failures also expose `FailureCount`
+and `RetryAt`. A valid provider `Retry-After` header is recorded as typed
+`RetryAfterSeconds` or `RetryAfterDate`, never as raw header text. These fields
+are diagnostic only and do not change the persisted retry schedule. For
+example, a 503 with `Transient error; please try again later` and
+`Retry-After: 120` reports a transient error and 120 seconds; it does not stop
+polling or prove why a broadcast was missed.
+
+Both named YouTube HTTP clients cap response buffering at 1 MiB, including
+responses without a Content-Length header. The existing request timeouts still
+cover buffering. Responses exceeding that limit fail before diagnostic body
+classification; they are logged as request failures, not offline observations.
+The 4,096-character classification limit applies within that response-size cap.
+
+When `WebhookSecret` is configured, the callback acknowledges notifications with missing, invalid, or mismatched
+signatures with HTTP 200, as required by PubSubHubbub authenticated content
+distribution, but discards them before parsing, state updates, coordination,
+or confirmation queuing. A warning explicitly records the discard. HTTP 200
+does not mean that a notification was authenticated or processed. Development
+overrides still require both a valid signature and the dev command secret.
+If `WebhookSecret` is empty, the callback instead returns HTTP 503 before
+signature validation and logs the missing configuration.
+
+A denial GET requires `hub.topic`, but not a challenge, lease, or verification
+token. The static callback cannot authenticate these reports, so it logs only
+topic presence, a nullable comparison with the configured channel's topic,
+reason presence/length, and a bounded fixed classification. If only a channel
+handle is configured, topic correlation is unavailable. Even a matching topic
+does not authenticate the sender. Denials never confirm, revoke, clear, or
+otherwise change subscription state, live status, backoff, or polling.
+Subscribe verification still requires the matching `hub.verify_token`,
+challenge, and valid lease; repeated matching verifications retain the original
+renewal deadline.
+
+Rejected verification callbacks log a fixed `RejectionReason` (`Malformed` or
+`Unexpected`), a `ModeClassification` (`Subscribe`, `Unsubscribe`, or `Unknown`),
+`TopicPresent`, and nullable `MatchesConfiguredTopic`. Neither submitted modes
+nor topics enter the formatted message or structured fields. Topic correlation
+is diagnostic only, not callback authorization.
+
+Twitch callback diagnostics retain rejected timestamps, unknown message types,
+and replay/in-progress message IDs as sanitized fields: values are bounded to
+128 characters (including an ellipsis when truncated), and characters outside
+ASCII letters, digits, `_`, `.`, `:`,
+`+`, and `-` are replaced with `_`. This preserves ordinary RFC3339 timestamps
+and message-type names without letting line separators or control characters
+forge log entries. Revocations retain the subscription ID, type, and status using
+the same sanitizer, but omit the full body, transport URLs, and any other payload
+fields. Invalid revocation JSON still returns the original acknowledgment and
+logs that details were unavailable. Signature validation, freshness checks,
+replay coordination, challenge responses, and HTTP statuses are unchanged.
+
+Successful discovery logs `LastSuccessfulDiscoveryAt`, `LastDiscoveryLive`,
+and `NextDiscoveryAt`. The worker includes its last successful discovery time
+and result in subsequent failure logs, so operators can distinguish a
+successful offline observation from unavailable detection. These are
+process-local diagnostic values, not new Redis or public snapshot fields;
+they start empty after a restart, channel change, or before the first successful
+discovery.
+The reset happens before resolving changed channel settings, so a failed
+resolution cannot report a previous channel's successful discovery.
+A later successful check advances the timestamp, indicating polling recovery.
+Known-video and notification checks log `CheckedAt` and `ObservedLive`.
+These observations precede the guarded state update: an offline observation
+does not bypass the configured two-check confirmation rule.
+
+Without a useful notification, a new broadcast may take up to the configured
+30-minute discovery interval (plus request/tick delays) to be detected.
+Failures can extend that delay. Google's current
+[quota guide](https://developers.google.com/youtube/v3/determine_quota_cost) and
+[`search.list` reference](https://developers.google.com/youtube/v3/docs/search/list)
+describe a separate Search Queries bucket: one unit per search call, with a
+default limit of 100 calls per day. Other endpoints used here (`channels.list`
+and `videos.list`) each cost one unit in the general bucket, whose default daily
+allocation is 10,000 units. Actual project limits and usage must be checked in
+Google Cloud; daily quotas reset at midnight Pacific Time.
+
+The default idle schedule permits approximately 48 scheduled searches per
+24 hours for a continuously running leader before retries. Known-video checks
+can make 720 calls per 24 hours while continuously live. A Pacific calendar day
+can be 23 or 25 hours at daylight-saving transitions.
+
+These intervals are **not project-wide daily quota enforcement**. Notification
+confirmation searches use a separate Redis gate that admits a confirmation
+every 30 seconds, not the discovery interval. Data API resilience retries,
+restarts/leader changes (the next discovery timestamp is process-local), and
+other clients sharing the Google Cloud project can add usage. A budget must
+account for each outbound attempt across these paths and all replicas, not just
+successful worker ticks. The current implementation does not maintain such a
+shared daily budget.
+
+The WebSub subscription POST does not use a Data API key. Its Retry-After and
+subscription backoff are separate from Data API quota accounting; the observed
+hub 503 does not establish quota exhaustion. These diagnostic changes do not
+alter polling intervals, retry policies, or leader coordination.
+
## Configuration
Bind from the `Live` section of configuration. In unconfigured local runs,
@@ -311,6 +453,13 @@ dotnet test .\tests\Aspire.Dev.AppHost.Tests\Aspire.Dev.AppHost.Tests.csproj --c
dotnet test .\tests\StaticHost.Tests\StaticHost.Tests.csproj --configuration Release --filter "Category!=RedisIntegration"
```
+For the focused YouTube diagnostics, callback authorization, and polling regressions, explicitly keep
+frontend build scripts and package installation disabled:
+
+```powershell
+dotnet test .\tests\StaticHost.Tests\StaticHost.Tests.csproj --configuration Release --filter "(FullyQualifiedName~YouTube|FullyQualifiedName~LiveEndpointsTests)&Category!=RedisIntegration" -p:ShouldRunBuildScript=false -p:ShouldRunNpmInstall=false
+```
+
The real-Redis group has the xUnit trait `Category=RedisIntegration` and requires
a running container runtime, such as Docker. Following the
[Aspire testing pattern](https://aspire.dev/testing/overview/), its shared fixture
diff --git a/src/statichost/StaticHost/Live/Twitch/TwitchWebhookHandler.cs b/src/statichost/StaticHost/Live/Twitch/TwitchWebhookHandler.cs
index 68dd2424b..8b6b604d0 100644
--- a/src/statichost/StaticHost/Live/Twitch/TwitchWebhookHandler.cs
+++ b/src/statichost/StaticHost/Live/Twitch/TwitchWebhookHandler.cs
@@ -2,6 +2,7 @@
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
+using System.Text.RegularExpressions;
namespace StaticHost.Live.Twitch;
@@ -56,6 +57,42 @@ public static bool IsFresh(string timestamp, DateTimeOffset now, TimeSpan maxAge
return age <= maxAge && age >= TimeSpan.FromMinutes(-1);
}
+ internal static string SanitizeDiagnosticValue(string value)
+ {
+ const int maxLength = 128;
+ var bounded = value.Length > maxLength ? value[..(maxLength - 3)] + "..." : value;
+ return Regex.Replace(bounded, "[^a-zA-Z0-9_.:+-]", "_");
+ }
+
+ private static void LogRevocation(string bodyJson, ILogger logger)
+ {
+ try
+ {
+ using var document = JsonDocument.Parse(bodyJson);
+ if (document.RootElement.ValueKind != JsonValueKind.Object ||
+ !document.RootElement.TryGetProperty("subscription", out var subscription) ||
+ subscription.ValueKind != JsonValueKind.Object)
+ {
+ logger.LogWarning("Twitch EventSub subscription revoked; subscription details unavailable.");
+ return;
+ }
+
+ // Retain the subscription state, not transport URLs or other payload data.
+ logger.LogWarning(
+ "Twitch EventSub subscription revoked (Id: {SubscriptionId}, Type: {SubscriptionType}, Status: {SubscriptionStatus}).",
+ LogField("id"), LogField("type"), LogField("status"));
+
+ string LogField(string name) =>
+ subscription.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
+ ? SanitizeDiagnosticValue(value.GetString()!)
+ : "";
+ }
+ catch (JsonException)
+ {
+ logger.LogWarning("Twitch EventSub subscription revoked; payload is not valid JSON.");
+ }
+ }
+
///
/// Branches on Twitch-Eventsub-Message-Type:
///
@@ -121,10 +158,11 @@ await broadcaster.UpdateAsync(
return Results.Ok();
}
case "revocation":
- logger.LogWarning("Twitch EventSub subscription revoked: {Body}", bodyJson);
+ LogRevocation(bodyJson, logger);
return Results.NoContent();
default:
- logger.LogDebug("Twitch webhook of unknown message-type {Type}", messageType);
+ logger.LogDebug("Twitch webhook of unknown message type {MessageType} (sanitized).",
+ SanitizeDiagnosticValue(messageType));
return Results.Ok();
}
}
diff --git a/src/statichost/StaticHost/Live/YouTube/YouTubeClient.cs b/src/statichost/StaticHost/Live/YouTube/YouTubeClient.cs
index 106715fea..153ee6036 100644
--- a/src/statichost/StaticHost/Live/YouTube/YouTubeClient.cs
+++ b/src/statichost/StaticHost/Live/YouTube/YouTubeClient.cs
@@ -11,6 +11,8 @@ public sealed class YouTubeClient(
IOptionsMonitor options,
ILogger logger) : IYouTubeClient
{
+ internal const int ResponseBufferLimit = 1024 * 1024;
+
/// Name of the registered for the Data API.
public const string HttpClientName = "youtube";
@@ -34,7 +36,8 @@ private HttpClient ApiClient()
var url = $"channels?part=id&forHandle={Uri.EscapeDataString(clean)}&key={Uri.EscapeDataString(apiKey)}";
using var response = await ApiClient().GetAsync(url, cancellationToken).ConfigureAwait(false);
- response.EnsureSuccessStatusCode();
+ await YouTubeDiagnostics.EnsureSuccessAsync(response, cancellationToken,
+ apiKey, options.CurrentValue.YouTube.WebhookSecret).ConfigureAwait(false);
using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -56,7 +59,8 @@ public async Task GetCurrentLiveAsync(string channelId, Cance
var url = $"search?part=id&channelId={Uri.EscapeDataString(channelId)}&eventType=live&type=video&key={Uri.EscapeDataString(apiKey)}";
using var response = await ApiClient().GetAsync(url, cancellationToken).ConfigureAwait(false);
- response.EnsureSuccessStatusCode();
+ await YouTubeDiagnostics.EnsureSuccessAsync(response, cancellationToken,
+ apiKey, options.CurrentValue.YouTube.WebhookSecret).ConfigureAwait(false);
using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -80,7 +84,8 @@ public async Task GetVideoLiveStatusAsync(string videoId, Can
var url = $"videos?part=liveStreamingDetails&id={Uri.EscapeDataString(videoId)}&key={Uri.EscapeDataString(apiKey)}";
using var response = await ApiClient().GetAsync(url, cancellationToken).ConfigureAwait(false);
- response.EnsureSuccessStatusCode();
+ await YouTubeDiagnostics.EnsureSuccessAsync(response, cancellationToken,
+ apiKey, options.CurrentValue.YouTube.WebhookSecret).ConfigureAwait(false);
using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -129,9 +134,9 @@ public async Task SubscribeAsync(
using var response = await c.PostAsync("subscribe", form, cancellationToken).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
- var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
- logger.LogDebug("YouTube WebSub subscribe failed: {Status} {Body}", response.StatusCode, body);
- response.EnsureSuccessStatusCode();
+ logger.LogDebug("YouTube WebSub hub returned HTTP {StatusCode}.", (int)response.StatusCode);
+ await YouTubeDiagnostics.EnsureSuccessAsync(response, cancellationToken,
+ options.CurrentValue.YouTube.ApiKey, secret, verifyToken).ConfigureAwait(false);
}
}
}
diff --git a/src/statichost/StaticHost/Live/YouTube/YouTubeDiagnostics.cs b/src/statichost/StaticHost/Live/YouTube/YouTubeDiagnostics.cs
new file mode 100644
index 000000000..36073c282
--- /dev/null
+++ b/src/statichost/StaticHost/Live/YouTube/YouTubeDiagnostics.cs
@@ -0,0 +1,187 @@
+using System.Diagnostics;
+using System.Net.Sockets;
+using System.Text.Json;
+using Microsoft.AspNetCore.WebUtilities;
+using Polly.Timeout;
+
+namespace StaticHost.Live.YouTube;
+
+internal static class YouTubeDiagnostics
+{
+ internal const string ChannelsEndpoint = "www.googleapis.com/youtube/v3/channels";
+ internal const string SearchEndpoint = "www.googleapis.com/youtube/v3/search";
+ internal const string VideosEndpoint = "www.googleapis.com/youtube/v3/videos";
+ internal const string SubscribeEndpoint = "pubsubhubbub.appspot.com/subscribe";
+ private const string DetailsKey = "YouTube.ResponseDiagnostics";
+ private const string LoggedKey = "YouTube.FailureLogged";
+ private const int BodyLimit = 4096;
+
+ private sealed record ResponseDetails(string? Reason, string? Domain, string Detail, bool Truncated)
+ {
+ public double? RetryAfterSeconds { get; init; }
+ public DateTimeOffset? RetryAfterDate { get; init; }
+ }
+
+ internal static async Task EnsureSuccessAsync(
+ HttpResponseMessage response, CancellationToken cancellationToken, params string[] secrets)
+ {
+ if (response.IsSuccessStatusCode) return;
+
+ ResponseDetails details;
+ try
+ {
+ using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+ using var reader = new StreamReader(stream);
+ var buffer = new char[BodyLimit + 1];
+ var count = await reader.ReadBlockAsync(buffer.AsMemory(), cancellationToken).ConfigureAwait(false);
+ details = DescribeBody(new string(buffer, 0, Math.Min(count, BodyLimit)), count > BodyLimit, secrets);
+ }
+ catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+ catch (Exception)
+ {
+ // Diagnostic decoding must never replace the original HTTP failure.
+ details = new(null, null, "Response body could not be read; body omitted", false);
+ }
+
+ var retryAfter = response.Headers.RetryAfter;
+ details = details with
+ {
+ RetryAfterSeconds = retryAfter?.Delta?.TotalSeconds,
+ RetryAfterDate = retryAfter?.Date,
+ };
+
+ try
+ {
+ response.EnsureSuccessStatusCode();
+ }
+ catch (HttpRequestException exception)
+ {
+ exception.Data[DetailsKey] = details;
+ throw;
+ }
+ }
+
+ private static ResponseDetails DescribeBody(string body, bool truncated, string[] secrets)
+ {
+ try
+ {
+ using var doc = JsonDocument.Parse(body);
+ if (doc.RootElement.ValueKind == JsonValueKind.Object &&
+ doc.RootElement.TryGetProperty("error", out var error) &&
+ error.ValueKind == JsonValueKind.Object &&
+ error.TryGetProperty("errors", out var errors) &&
+ errors.ValueKind == JsonValueKind.Array && errors.GetArrayLength() > 0 &&
+ errors[0].ValueKind == JsonValueKind.Object)
+ {
+ return new(
+ ReadCode(errors[0], "reason", secrets),
+ ReadCode(errors[0], "domain", secrets),
+ "Google structured error; message omitted", truncated);
+ }
+ }
+ catch (JsonException) { }
+
+ return new(null, null, ClassifyProviderText(body), truncated);
+ }
+
+ internal static void LogUntrustedDenial(
+ ILogger logger, string reason, bool topicPresent, bool? matchesConfiguredTopic)
+ {
+ var truncated = reason.Length > BodyLimit;
+ logger.LogWarning(
+ "YouTube {Operation}: untrusted, unauthenticated denial report; not proof of a hub decision. " +
+ "Topic present {TopicPresent}, matches configured topic {MatchesConfiguredTopic}; " +
+ "reason present {ReasonPresent}, length {ReasonLength}, detail {ProviderDetail}, truncated {BodyTruncated}. " +
+ "Subscription state and live-status polling are unchanged.",
+ "WebSubDenialReport", topicPresent, matchesConfiguredTopic, reason.Length > 0, reason.Length,
+ ClassifyProviderText(truncated ? reason[..BodyLimit] : reason), truncated);
+ }
+
+ private static string ClassifyProviderText(string text)
+ {
+ // Only fixed classifications leave this boundary, never echoed HTML, URLs,
+ // callback values or arbitrary provider messages.
+ return text.Contains("temporarily unavailable", StringComparison.OrdinalIgnoreCase)
+ ? "Provider reports temporary unavailability"
+ : text.Contains("transient error", StringComparison.OrdinalIgnoreCase)
+ ? "Provider reports a transient error"
+ : text.Contains("invalid topic", StringComparison.OrdinalIgnoreCase)
+ ? "Provider reports an invalid topic"
+ : text.Contains("verification failed", StringComparison.OrdinalIgnoreCase)
+ ? "Provider reports callback verification failure"
+ : "Unrecognized provider response; body omitted";
+ }
+
+ private static string? ReadCode(JsonElement error, string name, string[] secrets)
+ {
+ if (!error.TryGetProperty(name, out var property) || property.ValueKind != JsonValueKind.String)
+ return null;
+ var value = property.GetString();
+ if (string.IsNullOrEmpty(value) || value.Length > 64 ||
+ value.Any(c => !char.IsAsciiLetterOrDigit(c) && c is not '.' and not '_' and not '-') ||
+ secrets.Any(secret => !string.IsNullOrEmpty(secret) && value.Contains(secret, StringComparison.Ordinal)))
+ return null;
+ return value;
+ }
+
+ internal static void LogFailure(
+ ILogger logger, Exception exception, string operation, string endpoint,
+ YouTubeWebSubRetryState? retry = null,
+ DateTimeOffset? lastSuccessfulDiscoveryAt = null, bool? lastDiscoveryLive = null,
+ bool skipIfLogged = false, double? elapsedMs = null)
+ {
+ if (skipIfLogged && exception.Data[LoggedKey] is true)
+ {
+ exception.Data.Remove(LoggedKey);
+ return;
+ }
+ exception.Data[LoggedKey] = true;
+ var details = exception.Data[DetailsKey] as ResponseDetails;
+ var http = exception as HttpRequestException;
+ var status = http?.StatusCode is { } code ? (int?)code : null;
+ var timeout = exception is OperationCanceledException or TimeoutException or TimeoutRejectedException;
+ SocketException? socket = null;
+ var inner = exception.InnerException;
+ for (var depth = 0; inner is not null && depth < 4; depth++, inner = inner.InnerException)
+ {
+ socket ??= inner as SocketException;
+ timeout |= inner is TimeoutException or TimeoutRejectedException;
+ }
+ var expected = http is not null || timeout || exception is JsonException;
+ var message =
+ "YouTube {Operation} failed at {Endpoint} after {ElapsedMs} ms: {FailureType}, HTTP {StatusCode} {StatusReason}; " +
+ "provider reason {ProviderReason}, domain {ProviderDomain}, detail {ProviderDetail}, truncated {BodyTruncated}; " +
+ "provider Retry-After seconds {RetryAfterSeconds}, date {RetryAfterDate}; " +
+ "timeout {IsTimeout}, network {HttpRequestError}, socket {SocketError}, inner failure {InnerFailureType}. " +
+ "Last successful discovery {LastSuccessfulDiscoveryAt}, live {LastDiscoveryLive}. Failure is not an offline observation.";
+ List fields =
+ [
+ operation, endpoint, elapsedMs, exception.GetType().Name, status,
+ status is { } number ? ReasonPhrases.GetReasonPhrase(number) : null,
+ details?.Reason, details?.Domain, details?.Detail, details?.Truncated,
+ details?.RetryAfterSeconds, details?.RetryAfterDate,
+ timeout, http?.HttpRequestError, socket?.SocketErrorCode, exception.InnerException?.GetType().Name,
+ lastSuccessfulDiscoveryAt, lastDiscoveryLive,
+ ];
+ if (operation == "WebSubSubscribe")
+ {
+ message += " Attempt {FailureCount}. Next subscription attempt no earlier than {RetryAt}. " +
+ "Live-status polling remains independently scheduled; this does not indicate a successful poll.";
+ fields.Add(retry?.FailureCount);
+ fields.Add(retry?.RetryAt);
+ }
+ else if (operation == "BackgroundTick")
+ {
+ message += " The worker will retry on its normal tick schedule.";
+ }
+ if (!expected)
+ {
+ // Render frames independently: exception messages, ToString overrides,
+ // source paths and argument values must not enter the log.
+ var stack = new StackTrace(exception, fNeedFileInfo: false).ToString();
+ message += " Safe stack trace: {SafeStackTrace}";
+ fields.Add(stack.Length > 8192 ? stack[..8192] + " [truncated]" : stack);
+ }
+ logger.Log(expected ? LogLevel.Warning : LogLevel.Error, message, fields.ToArray());
+ }
+}
diff --git a/src/statichost/StaticHost/Live/YouTube/YouTubeLiveConfirmationQueue.cs b/src/statichost/StaticHost/Live/YouTube/YouTubeLiveConfirmationQueue.cs
index e2eff8064..1d5caf43f 100644
--- a/src/statichost/StaticHost/Live/YouTube/YouTubeLiveConfirmationQueue.cs
+++ b/src/statichost/StaticHost/Live/YouTube/YouTubeLiveConfirmationQueue.cs
@@ -61,7 +61,8 @@ await LiveStatusEndpointRouteBuilderExtensions.ConfirmYouTubeLiveStatusAsync(
}
catch (Exception ex)
{
- logger.LogWarning(ex, "Confirming poll after YouTube webhook failed.");
+ YouTubeDiagnostics.LogFailure(logger, ex, "NotificationConfirmation", "local coordination/state",
+ skipIfLogged: true);
}
}
}
diff --git a/src/statichost/StaticHost/Live/YouTube/YouTubeWebSubService.cs b/src/statichost/StaticHost/Live/YouTube/YouTubeWebSubService.cs
index f60955e26..cdab0af43 100644
--- a/src/statichost/StaticHost/Live/YouTube/YouTubeWebSubService.cs
+++ b/src/statichost/StaticHost/Live/YouTube/YouTubeWebSubService.cs
@@ -1,5 +1,5 @@
+using System.Diagnostics;
using Microsoft.Extensions.Options;
-using Polly.Timeout;
namespace StaticHost.Live.YouTube;
@@ -30,6 +30,10 @@ public sealed class YouTubeWebSubService(
private DateTimeOffset _nextDiscoveryPollAt = DateTimeOffset.MinValue;
private string? _resolvedChannelHandle;
private string? _resolvedChannelId;
+ private DateTimeOffset? _lastSuccessfulDiscoveryAt;
+ private bool? _lastDiscoveryLive;
+ private string? _diagnosticConfiguredChannelId;
+ private string? _diagnosticChannelHandle;
///
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -63,7 +67,9 @@ private async Task RunLeaderAsync(CancellationToken stoppingToken)
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested) { return; }
catch (Exception ex)
{
- logger.LogError(ex, "YouTube WebSub tick failed; will retry.");
+ YouTubeDiagnostics.LogFailure(logger, ex, "BackgroundTick", "local coordination/state",
+ lastSuccessfulDiscoveryAt: _lastSuccessfulDiscoveryAt, lastDiscoveryLive: _lastDiscoveryLive,
+ skipIfLogged: true);
}
try
@@ -80,6 +86,15 @@ internal async Task TickAsync(CancellationToken cancellationToken)
var opts = options.CurrentValue;
var youtube = opts.YouTube;
+ if (!string.Equals(_diagnosticConfiguredChannelId, youtube.ChannelId, StringComparison.Ordinal) ||
+ !string.Equals(_diagnosticChannelHandle, youtube.ChannelHandle, StringComparison.OrdinalIgnoreCase))
+ {
+ _diagnosticConfiguredChannelId = youtube.ChannelId;
+ _diagnosticChannelHandle = youtube.ChannelHandle;
+ _lastSuccessfulDiscoveryAt = null;
+ _lastDiscoveryLive = null;
+ }
+
var channelId = youtube.ChannelId;
if (string.IsNullOrEmpty(channelId))
{
@@ -92,12 +107,19 @@ internal async Task TickAsync(CancellationToken cancellationToken)
channelId = _resolvedChannelId ?? "";
if (string.IsNullOrEmpty(channelId))
{
- channelId = await client.ResolveChannelIdAsync(youtube.ChannelHandle, cancellationToken).ConfigureAwait(false) ?? "";
+ channelId = await RunOperationAsync("ChannelResolution", YouTubeDiagnostics.ChannelsEndpoint,
+ () => client.ResolveChannelIdAsync(youtube.ChannelHandle, cancellationToken),
+ cancellationToken).ConfigureAwait(false) ?? "";
+ if (!string.IsNullOrEmpty(channelId))
+ {
+ logger.LogInformation("YouTube {Operation} succeeded at {CheckedAt}.", "ChannelResolution", _time.GetUtcNow());
+ }
}
if (string.IsNullOrEmpty(channelId))
{
- logger.LogWarning("Could not resolve YouTube channel id for {Handle}.", youtube.ChannelHandle);
+ logger.LogWarning("YouTube {Operation} returned no channel; live detection is unavailable, not confirmed offline.",
+ "ChannelResolution");
return;
}
@@ -115,6 +137,7 @@ internal async Task TickAsync(CancellationToken cancellationToken)
if (request is not null)
{
var requestSent = false;
+ var started = Stopwatch.GetTimestamp();
try
{
var callback = $"{opts.PublicBaseUrl.TrimEnd('/')}/api/live/youtube/webhook";
@@ -134,31 +157,21 @@ await client.SubscribeAsync(
}
catch (Exception ex)
{
+ var elapsedMs = Stopwatch.GetElapsedTime(started).TotalMilliseconds;
var retry = await _subscriptions.MarkRequestFailedAsync(
request,
CancellationToken.None).ConfigureAwait(false);
- if (ex is HttpRequestException or OperationCanceledException or TimeoutRejectedException)
- {
- if (retry is not null)
- {
- logger.LogWarning(
- "YouTube WebSub subscribe failed ({FailureType}, HTTP {StatusCode}); attempt {FailureCount}. " +
- "Next subscription attempt no earlier than {RetryAt}. Live-status polling continues.",
- ex.GetType().Name,
- (ex as HttpRequestException)?.StatusCode,
- retry.FailureCount,
- retry.RetryAt);
- }
- logger.LogDebug(ex, "YouTube WebSub subscription request failure details.");
- }
- else
- {
- logger.LogError(ex, "Unexpected YouTube WebSub subscription failure.");
- }
+ YouTubeDiagnostics.LogFailure(logger, ex, "WebSubSubscribe", YouTubeDiagnostics.SubscribeEndpoint,
+ retry, _lastSuccessfulDiscoveryAt, _lastDiscoveryLive, elapsedMs: elapsedMs);
}
if (requestSent)
{
+ var elapsedMs = Stopwatch.GetElapsedTime(started).TotalMilliseconds;
+ logger.LogInformation(
+ "YouTube {Operation} accepted at {AcceptedAt} after {ElapsedMs} ms; HTTP acceptance does not establish a verified lease. " +
+ "Only a matching verification callback establishes or renews the subscription.",
+ "WebSubSubscribe", _time.GetUtcNow(), elapsedMs);
await _subscriptions.MarkRequestSentAsync(
request,
_time.GetUtcNow(),
@@ -171,12 +184,24 @@ await _subscriptions.MarkRequestSentAsync(
var current = observed.Snapshot.YouTube;
if (current.Live && !string.IsNullOrEmpty(current.VideoId))
{
- live = await client.GetVideoLiveStatusAsync(current.VideoId, cancellationToken).ConfigureAwait(false);
+ live = await RunOperationAsync("KnownVideoStatus", YouTubeDiagnostics.VideosEndpoint,
+ () => client.GetVideoLiveStatusAsync(current.VideoId, cancellationToken),
+ cancellationToken).ConfigureAwait(false);
+ logger.LogInformation("YouTube {Operation} succeeded at {CheckedAt}; observed live {ObservedLive}.",
+ "KnownVideoStatus", _time.GetUtcNow(), live.Live);
}
else if (now >= _nextDiscoveryPollAt)
{
_nextDiscoveryPollAt = now.AddSeconds(youtube.DiscoveryPollingIntervalSeconds);
- live = await client.GetCurrentLiveAsync(channelId, cancellationToken).ConfigureAwait(false);
+ live = await RunOperationAsync("OfflineDiscovery", YouTubeDiagnostics.SearchEndpoint,
+ () => client.GetCurrentLiveAsync(channelId, cancellationToken),
+ cancellationToken).ConfigureAwait(false);
+ _lastSuccessfulDiscoveryAt = _time.GetUtcNow();
+ _lastDiscoveryLive = live.Live;
+ logger.LogInformation(
+ "YouTube {Operation} succeeded; last successful discovery {LastSuccessfulDiscoveryAt}, live {LastDiscoveryLive}. " +
+ "Next discovery no earlier than {NextDiscoveryAt}.",
+ "OfflineDiscovery", _lastSuccessfulDiscoveryAt, _lastDiscoveryLive, _nextDiscoveryPollAt);
}
if (live is null)
@@ -195,4 +220,22 @@ await broadcaster.UpdateAsync(
},
cancellationToken).ConfigureAwait(false);
}
+
+ private async Task RunOperationAsync(
+ string operation, string endpoint, Func> action, CancellationToken cancellationToken)
+ {
+ var started = Stopwatch.GetTimestamp();
+ try
+ {
+ return await action().ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+ catch (Exception exception)
+ {
+ YouTubeDiagnostics.LogFailure(logger, exception, operation, endpoint,
+ lastSuccessfulDiscoveryAt: _lastSuccessfulDiscoveryAt, lastDiscoveryLive: _lastDiscoveryLive,
+ elapsedMs: Stopwatch.GetElapsedTime(started).TotalMilliseconds);
+ throw;
+ }
+ }
}
diff --git a/tests/StaticHost.Tests/Live/InMemoryLiveStatusInfrastructure.cs b/tests/StaticHost.Tests/Live/InMemoryLiveStatusInfrastructure.cs
index 6a4959fc6..02176ba5b 100644
--- a/tests/StaticHost.Tests/Live/InMemoryLiveStatusInfrastructure.cs
+++ b/tests/StaticHost.Tests/Live/InMemoryLiveStatusInfrastructure.cs
@@ -37,6 +37,8 @@ public ValueTask UpdateAsync(
internal sealed class SingleInstanceLiveStatusCoordination : ILiveStatusCoordination
{
+ public int YouTubeConfirmationRequests { get; private set; }
+
private const string CompletedMessage = "completed";
private readonly ConcurrentDictionary _twitchMessageIds =
@@ -70,6 +72,7 @@ public ValueTask TryQueueYouTubeConfirmationAsync(
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
+ YouTubeConfirmationRequests++;
return ValueTask.FromResult(true);
}
@@ -114,9 +117,21 @@ public ValueTask DisposeAsync()
internal sealed class YouTubeWebSubSubscriptionState(TimeProvider? timeProvider = null) : IYouTubeWebSubSubscriptionState
{
+ public Exception? MarkRequestSentException { get; set; }
private readonly Lock _gate = new();
private YouTubeWebSubSubscriptionData _state = YouTubeWebSubSubscriptionData.Empty;
+ public YouTubeWebSubSubscriptionData Current
+ {
+ get
+ {
+ lock (_gate)
+ {
+ return _state;
+ }
+ }
+ }
+
public ValueTask TryBeginSubscriptionAsync(
string channelId,
DateTimeOffset now,
@@ -156,6 +171,10 @@ public ValueTask MarkRequestSentAsync(
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
+ if (MarkRequestSentException is { } exception)
+ {
+ return ValueTask.FromException(exception);
+ }
lock (_gate)
{
diff --git a/tests/StaticHost.Tests/Live/LiveEndpointsTests.cs b/tests/StaticHost.Tests/Live/LiveEndpointsTests.cs
index aecc63861..15006b069 100644
--- a/tests/StaticHost.Tests/Live/LiveEndpointsTests.cs
+++ b/tests/StaticHost.Tests/Live/LiveEndpointsTests.cs
@@ -3,6 +3,7 @@
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
namespace StaticHost.Tests.Live;
@@ -155,6 +156,129 @@ await server.Broadcaster.UpdateAsync(new LiveStatusUpdate
Assert.Equal(HttpStatusCode.OK, replayResponse.StatusCode);
AssertNoStore(replayResponse);
Assert.False((await server.Broadcaster.GetCurrentAsync()).Twitch.Live);
+ Assert.Contains(server.Logs.Entries, entry =>
+ entry.Fields.TryGetValue("MessageId", out var id) && Equals(id, "test-message-1"));
+ }
+
+ [Fact]
+ public async Task TwitchWebhook_SignedUnparseableTimestamp_IsRejectedWithSanitizedHeader()
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ using var request = TwitchRequest(server, "notification", "{}",
+ timestamp: LiveTestHelpers.LogInjectionPayload);
+ using var response = await server.Client.SendAsync(request);
+
+ Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+ AssertNoStore(response);
+ Assert.False((await server.Broadcaster.GetCurrentAsync()).IsLive);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(LogLevel.Warning, entry.Level);
+ Assert.Equal("payload-sentinel__forged-line___", entry.Fields["Timestamp"]);
+ Assert.Equal("Twitch webhook timestamp payload-sentinel__forged-line___ (sanitized) is stale or unparseable; rejecting.",
+ entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
+
+ [Theory]
+ [InlineData(-11)]
+ [InlineData(5)]
+ public async Task TwitchWebhook_RejectedTimestamp_RetainsDiagnosticValue(int minutesFromNow)
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ var timestamp = server.Time.GetUtcNow().AddMinutes(minutesFromNow).ToString("O");
+ using var request = TwitchRequest(server, "notification", "{}", timestamp: timestamp);
+ using var response = await server.Client.SendAsync(request);
+
+ Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+ AssertNoStore(response);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(timestamp, entry.Fields["Timestamp"]);
+ Assert.Contains(timestamp, entry.Message);
+ LiveTestHelpers.AssertSafeLogs(server.Logs);
+ }
+
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public async Task TwitchWebhook_SignedDuplicateId_IsLoggedSafely(bool completed)
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ const string messageId = LiveTestHelpers.LogInjectionPayload;
+ var acquisition = await server.Coordination.AcquireTwitchMessageAsync(messageId);
+ Assert.Equal(TwitchMessageAcquisitionStatus.Acquired, acquisition.Status);
+ await using (var lease = Assert.IsAssignableFrom(acquisition.Lease))
+ {
+ if (completed) await lease.CompleteAsync();
+ using var request = TwitchRequest(server, "notification", "{}", messageId: messageId);
+ using var response = await server.Client.SendAsync(request);
+
+ Assert.Equal(completed ? HttpStatusCode.OK : HttpStatusCode.ServiceUnavailable, response.StatusCode);
+ AssertNoStore(response);
+ Assert.False((await server.Broadcaster.GetCurrentAsync()).IsLive);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(LogLevel.Debug, entry.Level);
+ Assert.Contains(completed ? "replay ignored" : "already being processed", entry.Message);
+ Assert.Equal("payload-sentinel__forged-line___", entry.Fields["MessageId"]);
+ Assert.Equal(completed
+ ? "Twitch webhook replay ignored for message payload-sentinel__forged-line___."
+ : "Twitch webhook message payload-sentinel__forged-line___ is already being processed; asking Twitch to retry.",
+ entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
+
+ server.Logs.Entries.Clear();
+ using var retry = TwitchRequest(server, "notification",
+ """{"subscription":{"type":"stream.online"},"event":{"broadcaster_user_login":"aspiredotdev"}}""",
+ messageId: messageId);
+ using var retryResponse = await server.Client.SendAsync(retry);
+ Assert.Equal(HttpStatusCode.OK, retryResponse.StatusCode);
+ Assert.Equal(!completed, (await server.Broadcaster.GetCurrentAsync()).Twitch.Live);
+ if (completed)
+ {
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal("payload-sentinel__forged-line___", entry.Fields["MessageId"]);
+ Assert.Equal("Twitch webhook replay ignored for message payload-sentinel__forged-line___.", entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
+ else
+ {
+ LiveTestHelpers.AssertSafeLogs(server.Logs);
+ }
+ }
+
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public async Task TwitchWebhook_SignedRevocationAndUnknownType_LogSafely(bool revocation)
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ var before = await server.Broadcaster.GetStateAsync();
+ using var request = TwitchRequest(
+ server, revocation ? "revocation" : LiveTestHelpers.LogInjectionPayload,
+ LiveTestHelpers.LogInjectionPayload);
+ using var response = await server.Client.SendAsync(request);
+
+ Assert.Equal(revocation ? HttpStatusCode.NoContent : HttpStatusCode.OK, response.StatusCode);
+ AssertNoStore(response);
+ Assert.Equal(before, await server.Broadcaster.GetStateAsync());
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(revocation ? LogLevel.Warning : LogLevel.Debug, entry.Level);
+ Assert.Contains(revocation ? "subscription revoked" : "unknown message type", entry.Message);
+ if (revocation)
+ {
+ LiveTestHelpers.AssertSafeLogs(server.Logs);
+ }
+ else
+ {
+ Assert.Equal("payload-sentinel__forged-line___", entry.Fields["MessageType"]);
+ Assert.Equal("Twitch webhook of unknown message type payload-sentinel__forged-line___ (sanitized).",
+ entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
}
[Fact]
@@ -175,6 +299,7 @@ public async Task YouTubeVerification_RetriesEchoNewChallengeWithoutExtendingRen
AssertNoStore(retry);
Assert.Equal("retry", await retry.Content.ReadAsStringAsync());
Assert.Equal(renewAt, await server.Subscriptions.GetRenewAtAsync());
+ LiveTestHelpers.AssertSafeLogs(server.Logs, pending.Topic, pending.VerifyToken);
}
[Theory]
@@ -201,25 +326,208 @@ public async Task YouTubeVerification_RejectsMalformedOrUnsolicitedConfirmation(
}
[Theory]
- [InlineData(true, HttpStatusCode.OK)]
- [InlineData(false, HttpStatusCode.Unauthorized)]
- public async Task YouTubeWebhook_ValidatesSignatureBeforeQueuing(bool valid, HttpStatusCode expected)
+ [InlineData("mode", true)]
+ [InlineData("unsubscribe", true)]
+ [InlineData("missing-topic", true)]
+ [InlineData("topic", true)]
+ [InlineData("topic", false)]
+ [InlineData("token", true)]
+ public async Task YouTubeVerification_RejectionLogsOnlyClassificationsAndSafeFields(
+ string invalid, bool configured)
{
- await using var server = await LiveHttpServer.StartAsync();
- const string body = "video-123";
- using var request = new HttpRequestMessage(HttpMethod.Post, "/api/live/youtube/webhook")
+ const string invalidVerifyToken = "verification-secret-sentinel\r\nforged-line\u0085\u2028\u2029";
+ await using var server = await LiveHttpServer.StartAsync(youtubeConfigured: configured);
+ var pending = Assert.IsType(
+ await server.Subscriptions.TryBeginSubscriptionAsync("channel-123", server.Time.GetUtcNow()));
+ var mode = invalid switch
{
- Content = new StringContent(body, Encoding.UTF8, "application/atom+xml"),
+ "mode" => LiveTestHelpers.LogInjectionPayload,
+ "unsubscribe" => "unsubscribe",
+ _ => "subscribe",
};
- request.Headers.Add("X-Hub-Signature", valid
- ? "sha1=" + Convert.ToHexStringLower(HMACSHA1.HashData(
- Encoding.UTF8.GetBytes(LiveHttpServer.WebhookSecret), Encoding.UTF8.GetBytes(body)))
- : "sha1=invalid");
+ var submitted = pending with
+ {
+ Topic = invalid switch
+ {
+ "missing-topic" => "",
+ "token" => pending.Topic,
+ _ => LiveTestHelpers.LogInjectionPayload,
+ },
+ VerifyToken = invalid == "token" ? invalidVerifyToken : pending.VerifyToken,
+ };
+ var before = server.Subscriptions.Current;
+ using var response = await server.Client.GetAsync(
+ VerificationUrl(submitted, LiveTestHelpers.LogInjectionPayload, mode: mode));
+
+ Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+ AssertNoStore(response);
+ Assert.Equal(before, server.Subscriptions.Current);
+ Assert.False((await server.Broadcaster.GetCurrentAsync()).IsLive);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(LogLevel.Warning, entry.Level);
+ Assert.Equal("WebSubVerification", entry.Fields["Operation"]);
+ Assert.Equal(invalid is "mode" or "unsubscribe" or "missing-topic" ? "Malformed" : "Unexpected",
+ entry.Fields["RejectionReason"]);
+ Assert.Equal(invalid == "mode" ? "Unknown" : invalid == "unsubscribe" ? "Unsubscribe" : "Subscribe",
+ entry.Fields["ModeClassification"]);
+ Assert.Equal(invalid != "missing-topic", entry.Fields["TopicPresent"]);
+ Assert.Equal(configured ? (bool?)(invalid == "token") : null, entry.Fields["MatchesConfiguredTopic"]);
+ LiveTestHelpers.AssertSafeLogs(server.Logs, pending.Topic, pending.VerifyToken, "verification-secret-sentinel");
+
+ using var confirmation = await server.Client.GetAsync(
+ VerificationUrl(pending, LiveTestHelpers.LogInjectionPayload));
+ Assert.Equal(HttpStatusCode.OK, confirmation.StatusCode);
+ Assert.Equal("text/plain", confirmation.Content.Headers.ContentType?.MediaType);
+ Assert.Equal(LiveTestHelpers.LogInjectionPayload, await confirmation.Content.ReadAsStringAsync());
+ Assert.True(await server.Subscriptions.GetRenewAtAsync() > server.Time.GetUtcNow());
+ LiveTestHelpers.AssertSafeLogs(server.Logs, pending.Topic, pending.VerifyToken, "verification-secret-sentinel");
+ }
+
+ [Theory]
+ [InlineData("valid")]
+ [InlineData("invalid")]
+ [InlineData("missing")]
+ [InlineData("tampered")]
+ public async Task YouTubeWebhook_AcknowledgesButOnlyQueuesValidSignatures(string signature)
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ await server.Broadcaster.UpdateAsync(new LiveStatusUpdate
+ {
+ YouTube = new YouTubeStatus(true, "existing-video"),
+ });
+ var before = await server.Broadcaster.GetStateAsync();
+ using var request = YouTubeRequest(signature);
+ using var response = await server.Client.SendAsync(request);
+
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ AssertNoStore(response);
+ Assert.Equal(before, await server.Broadcaster.GetStateAsync());
+ Assert.Equal(signature == "valid" ? 1 : 0, server.Coordination.YouTubeConfirmationRequests);
+ if (signature != "valid")
+ {
+ var warning = Assert.Single(server.Logs.Entries);
+ Assert.Equal(LogLevel.Warning, warning.Level);
+ Assert.Contains("acknowledging and discarding", warning.Message);
+ }
+ }
+
+ [Theory]
+ [InlineData("valid", false, HttpStatusCode.Unauthorized, false)]
+ [InlineData("valid", true, HttpStatusCode.OK, true)]
+ [InlineData("missing", true, HttpStatusCode.OK, false)]
+ [InlineData("tampered", true, HttpStatusCode.OK, false)]
+ public async Task YouTubeWebhook_DevOverrideStillRequiresSignatureAndCommandSecret(
+ string signature, bool correctSecret, HttpStatusCode expected, bool live)
+ {
+ await using var server = await LiveHttpServer.StartAsync(Environments.Development, youtubeConfigured: false);
+ using var request = YouTubeRequest(signature);
+ request.Headers.Add("X-Aspire-Live-Dev-Command-Key",
+ correctSecret ? "Key: local-test-command" : "Key: wrong-key");
using var response = await server.Client.SendAsync(request);
Assert.Equal(expected, response.StatusCode);
+ Assert.Equal(live, (await server.Broadcaster.GetCurrentAsync()).YouTube.Live);
+ Assert.Equal(0, server.Coordination.YouTubeConfirmationRequests);
+ }
+
+ [Theory]
+ [InlineData("pending")]
+ [InlineData("confirmed")]
+ [InlineData("backoff")]
+ public async Task YouTubeDenial_WithoutChallengeOrLease_DoesNotMutateState(string subscriptionState)
+ {
+ await using var server = await LiveHttpServer.StartAsync();
+ var pending = Assert.IsType(
+ await server.Subscriptions.TryBeginSubscriptionAsync("channel-123", server.Time.GetUtcNow()));
+ if (subscriptionState == "confirmed")
+ {
+ using var confirmation = await server.Client.GetAsync(VerificationUrl(pending, "challenge"));
+ Assert.Equal(HttpStatusCode.OK, confirmation.StatusCode);
+ }
+ else if (subscriptionState == "backoff")
+ {
+ await server.Subscriptions.MarkRequestFailedAsync(pending);
+ }
+ await server.Broadcaster.UpdateAsync(new LiveStatusUpdate { YouTube = new YouTubeStatus(true, "existing-video") });
+ var beforeLive = await server.Broadcaster.GetStateAsync();
+ var beforeSubscription = server.Subscriptions.Current;
+ server.Logs.Entries.Clear();
+
+ using var response = await server.Client.GetAsync(
+ $"/api/live/youtube/webhook?hub.mode=denied&hub.topic={Uri.EscapeDataString(pending.Topic)}" +
+ "&hub.reason=Transient%20error%3B%20please%20try%20again%20later");
+
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
AssertNoStore(response);
+ Assert.Equal(beforeSubscription, server.Subscriptions.Current);
+ Assert.Equal(beforeLive, await server.Broadcaster.GetStateAsync());
+ Assert.Equal(0, server.Coordination.YouTubeConfirmationRequests);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(LogLevel.Warning, entry.Level);
+ Assert.Equal("WebSubDenialReport", entry.Fields["Operation"]);
+ Assert.Equal(true, entry.Fields["MatchesConfiguredTopic"]);
+ Assert.Equal("Provider reports a transient error", entry.Fields["ProviderDetail"]);
+ Assert.Contains("untrusted, unauthenticated", entry.Message);
+ Assert.DoesNotContain(pending.Topic, entry.Message);
+ if (subscriptionState == "pending")
+ {
+ using var confirmation = await server.Client.GetAsync(VerificationUrl(pending, "still-pending"));
+ Assert.Equal(HttpStatusCode.OK, confirmation.StatusCode);
+ }
+ }
+
+ [Theory]
+ [InlineData(null, true, false)]
+ [InlineData("unknown", true, false)]
+ [InlineData("oversized", true, false)]
+ [InlineData("unknown", false, false)]
+ [InlineData("unknown", true, true)]
+ public async Task YouTubeDenial_UntrustedInputIsBoundedAndNotLogged(
+ string? reason, bool topicPresent, bool configured)
+ {
+ await using var server = await LiveHttpServer.StartAsync(youtubeConfigured: configured);
+ const string sensitive = "https://attacker.invalid/?secret=test-webhook-secret&token=private-token\r\nforged-log";
+ reason = reason is null ? null : reason == "oversized" ? new string('x', 5000) + sensitive : sensitive;
+ var url = "/api/live/youtube/webhook?hub.mode=denied";
+ if (topicPresent) url += "&hub.topic=" + Uri.EscapeDataString(sensitive);
+ if (reason is not null) url += "&hub.reason=" + Uri.EscapeDataString(reason);
+ url += "&hub.verify_token=private-token&hub.challenge=private-challenge";
+ var before = server.Subscriptions.Current;
+
+ using var response = await server.Client.GetAsync(url);
+
+ Assert.Equal(topicPresent ? HttpStatusCode.OK : HttpStatusCode.BadRequest, response.StatusCode);
+ Assert.Equal(before, server.Subscriptions.Current);
Assert.False((await server.Broadcaster.GetCurrentAsync()).IsLive);
+ Assert.Equal(0, server.Coordination.YouTubeConfirmationRequests);
+ var entry = Assert.Single(server.Logs.Entries);
+ Assert.Equal(topicPresent, entry.Fields["TopicPresent"]);
+ Assert.Equal(configured ? (bool?)false : null, entry.Fields["MatchesConfiguredTopic"]);
+ Assert.Equal(reason is not null, entry.Fields["ReasonPresent"]);
+ Assert.Equal(reason?.Length ?? 0, entry.Fields["ReasonLength"]);
+ Assert.Equal(reason?.Length > 4096, entry.Fields["BodyTruncated"]);
+ Assert.Equal("Unrecognized provider response; body omitted", entry.Fields["ProviderDetail"]);
+ Assert.DoesNotContain("attacker", entry.Message);
+ Assert.DoesNotContain("private-", entry.Message);
+ Assert.DoesNotContain(LiveHttpServer.WebhookSecret, entry.Message);
+ Assert.DoesNotContain("forged-log", entry.Message);
+ Assert.True(entry.Message.Length < 700);
+ }
+
+ private static HttpRequestMessage YouTubeRequest(string signature)
+ {
+ const string body = "video-123";
+ var request = new HttpRequestMessage(HttpMethod.Post, "/api/live/youtube/webhook")
+ {
+ Content = new StringContent(signature == "tampered" ? body + " " : body, Encoding.UTF8, "application/atom+xml"),
+ };
+ if (signature != "missing")
+ {
+ request.Headers.Add("X-Hub-Signature", signature == "invalid" ? "sha1=invalid" :
+ "sha1=" + Convert.ToHexStringLower(HMACSHA1.HashData(
+ Encoding.UTF8.GetBytes(LiveHttpServer.WebhookSecret), Encoding.UTF8.GetBytes(body))));
+ }
+ return request;
}
private static void AssertNoStore(HttpResponseMessage response) =>
@@ -239,17 +547,17 @@ private static HttpRequestMessage DevRequest(bool correctSecret)
}
private static HttpRequestMessage TwitchRequest(
- LiveHttpServer server, string messageType, string body, bool stale = false)
+ LiveHttpServer server, string messageType, string body, bool stale = false,
+ string messageId = "test-message-1", string? timestamp = null)
{
- const string messageId = "test-message-1";
- var timestamp = server.Time.GetUtcNow().AddMinutes(stale ? -11 : 0).ToString("O");
+ timestamp ??= server.Time.GetUtcNow().AddMinutes(stale ? -11 : 0).ToString("O");
var request = new HttpRequestMessage(HttpMethod.Post, "/api/live/twitch/webhook")
{
Content = new StringContent(body, Encoding.UTF8, "application/json"),
};
- request.Headers.Add("Twitch-Eventsub-Message-Id", messageId);
- request.Headers.Add("Twitch-Eventsub-Message-Timestamp", timestamp);
- request.Headers.Add("Twitch-Eventsub-Message-Type", messageType);
+ request.Headers.TryAddWithoutValidation("Twitch-Eventsub-Message-Id", messageId);
+ request.Headers.TryAddWithoutValidation("Twitch-Eventsub-Message-Timestamp", timestamp);
+ request.Headers.TryAddWithoutValidation("Twitch-Eventsub-Message-Type", messageType);
request.Headers.Add("Twitch-Eventsub-Message-Signature",
"sha256=" + Convert.ToHexStringLower(HMACSHA256.HashData(
Encoding.UTF8.GetBytes(LiveHttpServer.WebhookSecret),
@@ -260,29 +568,35 @@ private static HttpRequestMessage TwitchRequest(
private static string VerificationUrl(
YouTubeWebSubSubscriptionRequest pending, string challenge,
string lease = "432000", string mode = "subscribe") =>
- $"/api/live/youtube/webhook?hub.mode={mode}&hub.topic={Uri.EscapeDataString(pending.Topic)}" +
- $"&hub.verify_token={pending.VerifyToken}&hub.lease_seconds={lease}&hub.challenge={challenge}";
+ $"/api/live/youtube/webhook?hub.mode={Uri.EscapeDataString(mode)}&hub.topic={Uri.EscapeDataString(pending.Topic)}" +
+ $"&hub.verify_token={Uri.EscapeDataString(pending.VerifyToken)}&hub.lease_seconds={lease}&hub.challenge={Uri.EscapeDataString(challenge)}";
private sealed class LiveHttpServer(
WebApplication app, HttpClient client, FakeTimeProvider time,
- TaskCompletionSource streamEnded) : IAsyncDisposable
+ TaskCompletionSource streamEnded, YouTubeRecordingLogger logs) : IAsyncDisposable
{
public const string WebhookSecret = "test-webhook-secret";
public HttpClient Client { get; } = client;
public FakeTimeProvider Time { get; } = time;
public TaskCompletionSource StreamEnded { get; } = streamEnded;
public LiveStatusBroadcaster Broadcaster => app.Services.GetRequiredService();
- public IYouTubeWebSubSubscriptionState Subscriptions =>
- app.Services.GetRequiredService();
+ public YouTubeRecordingLogger Logs { get; } = logs;
+ public SingleInstanceLiveStatusCoordination Coordination =>
+ (SingleInstanceLiveStatusCoordination)app.Services.GetRequiredService();
+ public YouTubeWebSubSubscriptionState Subscriptions =>
+ (YouTubeWebSubSubscriptionState)app.Services.GetRequiredService();
public static async Task StartAsync(
- string environment = "Production", bool enableDev = true)
+ string environment = "Production", bool enableDev = true, bool youtubeConfigured = true)
{
var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
EnvironmentName = environment,
});
builder.WebHost.UseTestServer();
+ var logs = new YouTubeRecordingLogger();
+ builder.Logging.AddFilter(level => level >= LogLevel.Debug);
+ builder.Logging.AddProvider(new WebhookLoggerProvider(logs));
var time = new FakeTimeProvider(DateTimeOffset.UnixEpoch);
var options = new LiveStatusOptions
{
@@ -290,7 +604,12 @@ public static async Task StartAsync(
DevCommandSecret = "local-test-command",
CoalesceWindowMs = 0,
Twitch = new TwitchOptions { WebhookSecret = WebhookSecret },
- YouTube = new YouTubeOptions { WebhookSecret = WebhookSecret, ApiKey = "unused-test-key" },
+ YouTube = new YouTubeOptions
+ {
+ WebhookSecret = WebhookSecret,
+ ApiKey = youtubeConfigured ? "unused-test-key" : "",
+ ChannelId = youtubeConfigured ? "channel-123" : "",
+ },
};
builder.Services.AddSingleton(time);
builder.Services.AddSingleton>(Options.Create(options));
@@ -319,7 +638,16 @@ public static async Task StartAsync(
});
app.MapLiveStatus();
await app.StartAsync();
- return new LiveHttpServer(app, app.GetTestClient(), time, streamEnded);
+ return new LiveHttpServer(app, app.GetTestClient(), time, streamEnded, logs);
+ }
+
+ private sealed class WebhookLoggerProvider(ILogger logger) : ILoggerProvider
+ {
+ public ILogger CreateLogger(string categoryName) =>
+ categoryName.StartsWith("StaticHost.Live.YouTube.", StringComparison.Ordinal) ||
+ categoryName == "StaticHost.Live.Twitch.Webhook"
+ ? logger : NullLogger.Instance;
+ public void Dispose() { }
}
public async ValueTask DisposeAsync()
diff --git a/tests/StaticHost.Tests/Live/LiveTestHelpers.cs b/tests/StaticHost.Tests/Live/LiveTestHelpers.cs
index 482057710..8d5a3ad92 100644
--- a/tests/StaticHost.Tests/Live/LiveTestHelpers.cs
+++ b/tests/StaticHost.Tests/Live/LiveTestHelpers.cs
@@ -2,6 +2,38 @@ namespace StaticHost.Tests.Live;
internal static class LiveTestHelpers
{
+ // Non-secret fixture for testing log injection, distinct from verification credentials.
+ public const string LogInjectionPayload = "payload-sentinel\r\nforged-line\u0085\u2028\u2029";
+
+ public static void AssertSafeLogs(YouTubeRecordingLogger logger, params string[] omittedValues)
+ {
+ Assert.NotEmpty(logger.Entries);
+ foreach (var entry in logger.Entries)
+ {
+ Assert.Null(entry.Exception);
+ AssertSafeText(entry.Message);
+ foreach (var field in entry.Fields)
+ {
+ AssertSafeText(field.Key);
+ AssertSafeText(field.Value?.ToString() ?? "");
+ }
+ }
+
+ void AssertSafeText(string text)
+ {
+ Assert.DoesNotContain("payload-sentinel", text);
+ Assert.DoesNotContain("forged-line", text);
+ foreach (var separator in new[] { '\r', '\n', '\u0085', '\u2028', '\u2029' })
+ {
+ Assert.DoesNotContain(separator, text);
+ }
+ foreach (var value in omittedValues)
+ {
+ Assert.DoesNotContain(value, text);
+ }
+ }
+ }
+
public static LiveStatusBroadcaster CreateBroadcaster(
int coalesceMs = 0,
TimeProvider? timeProvider = null)
diff --git a/tests/StaticHost.Tests/Live/TwitchWebhookHandlerTests.cs b/tests/StaticHost.Tests/Live/TwitchWebhookHandlerTests.cs
index 42cba2071..cc19d6f61 100644
--- a/tests/StaticHost.Tests/Live/TwitchWebhookHandlerTests.cs
+++ b/tests/StaticHost.Tests/Live/TwitchWebhookHandlerTests.cs
@@ -1,3 +1,5 @@
+using Microsoft.Extensions.Logging;
+
namespace StaticHost.Tests.Live;
public sealed class TwitchWebhookHandlerTests
@@ -154,6 +156,141 @@ public void IsFresh_ReturnsFalseForUnparseableTimestamp(string timestamp)
Assert.False(TwitchWebhookHandler.IsFresh(timestamp, now, TimeSpan.FromMinutes(10)));
}
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public async Task Handle_UntrustedRevocationAndUnknownType_LogSafely(bool revocation)
+ {
+ var broadcaster = LiveTestHelpers.CreateBroadcaster();
+ var before = await broadcaster.GetStateAsync();
+ var logger = new YouTubeRecordingLogger();
+ var result = await TwitchWebhookHandler.HandleAsync(
+ revocation ? "revocation" : LiveTestHelpers.LogInjectionPayload,
+ LiveTestHelpers.LogInjectionPayload,
+ broadcaster,
+ new TwitchOptions(),
+ logger);
+ using var services = new ServiceCollection().AddLogging().BuildServiceProvider();
+ var context = new DefaultHttpContext
+ {
+ RequestServices = services,
+ };
+ context.Response.Body = new MemoryStream();
+
+ await result.ExecuteAsync(context);
+
+ Assert.Equal(revocation ? StatusCodes.Status204NoContent : StatusCodes.Status200OK,
+ context.Response.StatusCode);
+ Assert.Equal(before, await broadcaster.GetStateAsync());
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(revocation ? LogLevel.Warning : LogLevel.Debug,
+ entry.Level);
+ Assert.Contains(revocation ? "subscription revoked" : "unknown message type", entry.Message);
+ if (revocation)
+ {
+ LiveTestHelpers.AssertSafeLogs(logger);
+ }
+ else
+ {
+ Assert.Equal("payload-sentinel__forged-line___", entry.Fields["MessageType"]);
+ Assert.Equal("Twitch webhook of unknown message type payload-sentinel__forged-line___ (sanitized).",
+ entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
+ }
+
+ [Theory]
+ [InlineData("new_message_type", "new_message_type")]
+ [InlineData("new.message-type:1", "new.message-type:1")]
+ [InlineData("type\r\nother\u0085\u2028\u2029\u001b[31m", "type__other_____31m")]
+ public async Task Handle_UnknownMessageType_RetainsSanitizedDiagnosticValue(string messageType, string expected)
+ {
+ var logger = new YouTubeRecordingLogger();
+ await TwitchWebhookHandler.HandleAsync(messageType, "{}",
+ LiveTestHelpers.CreateBroadcaster(), new TwitchOptions(), logger);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(expected, entry.Fields["MessageType"]);
+ Assert.Equal($"Twitch webhook of unknown message type {expected} (sanitized).", entry.Message);
+ Assert.Null(entry.Exception);
+ Assert.Equal(2, entry.Fields.Count);
+ }
+
+ [Fact]
+ public async Task Handle_UnknownMessageType_BoundsDiagnosticLength()
+ {
+ var logger = new YouTubeRecordingLogger();
+ await TwitchWebhookHandler.HandleAsync(new string('a', 200), "{}",
+ LiveTestHelpers.CreateBroadcaster(), new TwitchOptions(), logger);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(new string('a', 125) + "...", entry.Fields["MessageType"]);
+ }
+
+ [Theory]
+ [InlineData("authorization_revoked")]
+ [InlineData("user_removed")]
+ [InlineData("version_removed")]
+ public async Task Handle_Revocation_RetainsUsefulSubscriptionDetailsOnly(string status)
+ {
+ var broadcaster = LiveTestHelpers.CreateBroadcaster();
+ var before = await broadcaster.GetStateAsync();
+ var logger = new YouTubeRecordingLogger();
+ var body = $$"""
+ {"subscription":{
+ "id":"subscription-123",
+ "type":"stream.online",
+ "status":"{{status}}",
+ "transport":{"callback":"https://example.invalid/callback?key=must-not-appear"}
+ },"extra":"body-only-marker"}
+ """;
+
+ var result = await TwitchWebhookHandler.HandleAsync(
+ "revocation", body, broadcaster, new TwitchOptions(), logger);
+
+ Assert.Equal(StatusCodes.Status204NoContent, Assert.IsAssignableFrom(result).StatusCode);
+ Assert.Equal(before, await broadcaster.GetStateAsync());
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal("subscription-123", entry.Fields["SubscriptionId"]);
+ Assert.Equal("stream.online", entry.Fields["SubscriptionType"]);
+ Assert.Equal(status, entry.Fields["SubscriptionStatus"]);
+ Assert.Equal(4, entry.Fields.Count);
+ LiveTestHelpers.AssertSafeLogs(logger, "must-not-appear", "example.invalid", "body-only-marker");
+ }
+
+ [Fact]
+ public async Task Handle_Revocation_SanitizesSubscriptionDetails()
+ {
+ var logger = new YouTubeRecordingLogger();
+ const string body = """{"subscription":{"id":"id\r\nnext","type":"stream.\u001bonline","status":"status\u2028next"}}""";
+
+ await TwitchWebhookHandler.HandleAsync("revocation", body,
+ LiveTestHelpers.CreateBroadcaster(), new TwitchOptions(), logger);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal("id__next", entry.Fields["SubscriptionId"]);
+ Assert.Equal("stream._online", entry.Fields["SubscriptionType"]);
+ Assert.Equal("status_next", entry.Fields["SubscriptionStatus"]);
+ LiveTestHelpers.AssertSafeLogs(logger);
+ }
+
+ [Theory]
+ [InlineData("{}")]
+ [InlineData("[]")]
+ [InlineData("{\"subscription\":null}")]
+ [InlineData("{\"subscription\":{\"id\":42,\"type\":[],\"status\":false}}")]
+ public async Task Handle_Revocation_MissingDetailsStillAcknowledges(string body)
+ {
+ var logger = new YouTubeRecordingLogger();
+ var result = await TwitchWebhookHandler.HandleAsync("revocation", body,
+ LiveTestHelpers.CreateBroadcaster(), new TwitchOptions(), logger);
+
+ Assert.Equal(StatusCodes.Status204NoContent, Assert.IsAssignableFrom(result).StatusCode);
+ Assert.Single(logger.Entries);
+ LiveTestHelpers.AssertSafeLogs(logger);
+ }
+
private static string ComputeTwitchSignature(string secret, string messageId, string timestamp, byte[] body)
{
using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
diff --git a/tests/StaticHost.Tests/Live/YouTubeClientTests.cs b/tests/StaticHost.Tests/Live/YouTubeClientTests.cs
index 7ecc32120..f574d1a72 100644
--- a/tests/StaticHost.Tests/Live/YouTubeClientTests.cs
+++ b/tests/StaticHost.Tests/Live/YouTubeClientTests.cs
@@ -142,6 +142,61 @@ public async Task PubSubHttpClient_HasBoundedTimeoutAndDoesNotRetryPosts()
Assert.Single(handler.Requests);
}
+ [Theory]
+ [InlineData(YouTubeClient.HttpClientName, HttpStatusCode.OK, true)]
+ [InlineData(YouTubeClient.HttpClientName, HttpStatusCode.OK, false)]
+ [InlineData(YouTubeClient.HttpClientName, HttpStatusCode.BadRequest, true)]
+ [InlineData(YouTubeClient.HttpClientName, HttpStatusCode.BadRequest, false)]
+ [InlineData(YouTubeClient.PubSubHttpClientName, HttpStatusCode.OK, true)]
+ [InlineData(YouTubeClient.PubSubHttpClientName, HttpStatusCode.OK, false)]
+ [InlineData(YouTubeClient.PubSubHttpClientName, HttpStatusCode.BadRequest, true)]
+ [InlineData(YouTubeClient.PubSubHttpClientName, HttpStatusCode.BadRequest, false)]
+ public async Task NamedYouTubeClients_BoundResponseBuffering(
+ string clientName, HttpStatusCode status, bool hasContentLength)
+ {
+ var builder = Host.CreateApplicationBuilder();
+ builder.AddLiveStatus();
+ using var content = new OversizedContent(hasContentLength);
+ var handler = new RecordingHttpMessageHandler(_ => new HttpResponseMessage(status) { Content = content });
+ builder.Services.AddHttpClient(clientName).ConfigurePrimaryHttpMessageHandler(() => handler);
+ using var host = builder.Build();
+ using var client = host.Services.GetRequiredService().CreateClient(clientName);
+ using var request = new HttpRequestMessage(
+ clientName == YouTubeClient.PubSubHttpClientName ? HttpMethod.Post : HttpMethod.Get,
+ "https://example.com/provider");
+
+ Assert.Equal(YouTubeClient.ResponseBufferLimit, client.MaxResponseContentBufferSize);
+ await Assert.ThrowsAsync(() => client.SendAsync(request));
+
+ Assert.Single(handler.Requests);
+ Assert.InRange(content.BytesAttempted, 0, YouTubeClient.ResponseBufferLimit + 1024);
+ if (!hasContentLength)
+ {
+ Assert.True(content.BytesAttempted > YouTubeClient.ResponseBufferLimit);
+ }
+ }
+
+ private sealed class OversizedContent(bool hasContentLength) : HttpContent
+ {
+ public int BytesAttempted { get; private set; }
+
+ protected override bool TryComputeLength(out long length)
+ {
+ length = YouTubeClient.ResponseBufferLimit * 2;
+ return hasContentLength;
+ }
+
+ protected override async Task SerializeToStreamAsync(Stream stream, System.Net.TransportContext? context)
+ {
+ var chunk = new byte[1024];
+ for (var written = 0; written < YouTubeClient.ResponseBufferLimit * 2; written += chunk.Length)
+ {
+ BytesAttempted += chunk.Length;
+ await stream.WriteAsync(chunk);
+ }
+ }
+ }
+
private static YouTubeClient CreateClient(
RecordingHttpMessageHandler? apiHandler = null,
RecordingHttpMessageHandler? pubSubHandler = null,
diff --git a/tests/StaticHost.Tests/Live/YouTubeDiagnosticsTests.cs b/tests/StaticHost.Tests/Live/YouTubeDiagnosticsTests.cs
new file mode 100644
index 000000000..9379febd1
--- /dev/null
+++ b/tests/StaticHost.Tests/Live/YouTubeDiagnosticsTests.cs
@@ -0,0 +1,423 @@
+using System.Net.Sockets;
+using System.Runtime.CompilerServices;
+using Microsoft.Extensions.Logging;
+
+namespace StaticHost.Tests.Live;
+
+public sealed class YouTubeDiagnosticsTests
+{
+ [Theory]
+ [InlineData("""{"error":{"errors":[{"reason":"quotaExceeded","domain":"youtube.quota"}],"message":"key=api-key secret verify-token"}}""", "quotaExceeded", "youtube.quota", false)]
+ [InlineData("""{"error":{"errors":[{"reason":"api-key","domain":"verify-token"}]}}""", null, null, false)]
+ [InlineData("""{"error":{"errors":[{"reason":"https://example.com/?key=api-key","domain":123}]}}""", null, null, false)]
+ [InlineData("""{"error":[]}""", null, null, false)]
+ [InlineData("""{"error":""", null, null, false)]
+ [InlineData("Temporarily unavailable api-key secret verify-token", null, null, false)]
+ [InlineData("Transient error; please try again later api-key secret verify-token", null, null, false)]
+ [InlineData("oversized", null, null, true)]
+ public async Task HttpFailure_ReportsOnlyBoundedSafeDiagnostics(
+ string body, string? reason, string? domain, bool truncated)
+ {
+ if (truncated) body = new string('x', 5000) + "api-key secret verify-token";
+ using var response = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
+ {
+ Content = new StringContent(body),
+ ReasonPhrase = "api-key secret verify-token",
+ };
+ var exception = await Assert.ThrowsAsync(() =>
+ YouTubeDiagnostics.EnsureSuccessAsync(response, CancellationToken.None, "api-key", "secret", "verify-token"));
+ var logger = new YouTubeRecordingLogger();
+
+ YouTubeDiagnostics.LogFailure(logger, exception, "WebSubSubscribe", YouTubeDiagnostics.SubscribeEndpoint);
+
+ Assert.Equal(HttpStatusCode.ServiceUnavailable, exception.StatusCode);
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(LogLevel.Warning, entry.Level);
+ Assert.Null(entry.Exception);
+ Assert.False(entry.Fields.ContainsKey("SafeStackTrace"));
+ Assert.Equal(503, entry.Fields["StatusCode"]);
+ Assert.Equal("Service Unavailable", entry.Fields["StatusReason"]);
+ Assert.Equal(reason, entry.Fields["ProviderReason"]);
+ Assert.Equal(domain, entry.Fields["ProviderDomain"]);
+ Assert.Equal(truncated, entry.Fields["BodyTruncated"]);
+ Assert.DoesNotContain("api-key", entry.Message);
+ Assert.DoesNotContain("verify-token", entry.Message);
+ Assert.DoesNotContain("secret", entry.Message);
+ Assert.DoesNotContain("", entry.Message);
+ Assert.True(entry.Message.Length < 1000);
+ if (body.StartsWith("", StringComparison.Ordinal))
+ Assert.Equal("Provider reports temporary unavailability", entry.Fields["ProviderDetail"]);
+ if (body.StartsWith("Transient error", StringComparison.Ordinal))
+ Assert.Equal("Provider reports a transient error", entry.Fields["ProviderDetail"]);
+ }
+
+ [Theory]
+ [InlineData(null, null, null)]
+ [InlineData("120", 120d, null)]
+ [InlineData("Wed, 16 Sep 2026 21:00:00 GMT", null, "2026-09-16T21:00:00Z")]
+ [InlineData("api-key secret verify-token", null, null)]
+ [InlineData("-120", null, null)]
+ [InlineData("oversized", null, null)]
+ public async Task HttpFailure_ReportsTypedRetryAfterWithoutRawHeaders(
+ string? header, double? seconds, string? date)
+ {
+ using var response = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
+ {
+ Content = new StringContent("Transient error; please try again later"),
+ };
+ if (header == "oversized") header = new string('9', 5000) + "api-key secret verify-token";
+ if (header is not null) response.Headers.TryAddWithoutValidation("Retry-After", header);
+ var exception = await Assert.ThrowsAsync(() =>
+ YouTubeDiagnostics.EnsureSuccessAsync(response, CancellationToken.None, "api-key", "secret", "verify-token"));
+ var logger = new YouTubeRecordingLogger();
+
+ YouTubeDiagnostics.LogFailure(logger, exception, "WebSubSubscribe", YouTubeDiagnostics.SubscribeEndpoint);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(seconds, entry.Fields["RetryAfterSeconds"]);
+ Assert.Equal(date is null ? (DateTimeOffset?)null : DateTimeOffset.Parse(date), entry.Fields["RetryAfterDate"]);
+ Assert.Equal("Provider reports a transient error", entry.Fields["ProviderDetail"]);
+ Assert.DoesNotContain("api-key", entry.Message);
+ Assert.DoesNotContain("secret", entry.Message);
+ Assert.DoesNotContain("verify-token", entry.Message);
+ Assert.True(entry.Message.Length < 1000);
+ }
+
+ [Fact]
+ public void DenialClassification_DoesNotReadBeyondDiagnosticLimit()
+ {
+ var logger = new YouTubeRecordingLogger();
+
+ YouTubeDiagnostics.LogUntrustedDenial(
+ logger, new string('x', 4096) + "Transient error", topicPresent: true, matchesConfiguredTopic: null);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(true, entry.Fields["BodyTruncated"]);
+ Assert.Equal("Unrecognized provider response; body omitted", entry.Fields["ProviderDetail"]);
+ }
+
+ [Fact]
+ public async Task UnreadableBody_DoesNotMaskHttpFailure()
+ {
+ using var response = new HttpResponseMessage(HttpStatusCode.BadGateway)
+ {
+ Content = new StreamContent(new UnreadableStream()),
+ };
+ response.Headers.RetryAfter = new System.Net.Http.Headers.RetryConditionHeaderValue(TimeSpan.FromSeconds(120));
+ var exception = await Assert.ThrowsAsync(() =>
+ YouTubeDiagnostics.EnsureSuccessAsync(response, CancellationToken.None));
+ var logger = new YouTubeRecordingLogger();
+ YouTubeDiagnostics.LogFailure(logger, exception, "OfflineDiscovery", YouTubeDiagnostics.SearchEndpoint);
+ Assert.Equal(HttpStatusCode.BadGateway, exception.StatusCode);
+ Assert.Equal("Response body could not be read; body omitted",
+ Assert.Single(logger.Entries).Fields["ProviderDetail"]);
+ Assert.Equal(120d, Assert.Single(logger.Entries).Fields["RetryAfterSeconds"]);
+ }
+
+ [Theory]
+ [InlineData(true)]
+ [InlineData(false)]
+ public void TransportFailure_ReportsCodesWithoutExceptionMessages(bool timeout)
+ {
+ Exception exception = timeout
+ ? new TaskCanceledException("https://example.com/?key=secret")
+ : new HttpRequestException(HttpRequestError.NameResolutionError, "key=secret",
+ new SocketException((int)SocketError.HostNotFound));
+ var logger = new YouTubeRecordingLogger();
+
+ YouTubeDiagnostics.LogFailure(logger, exception, "ChannelResolution", YouTubeDiagnostics.ChannelsEndpoint);
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(timeout, entry.Fields["IsTimeout"]);
+ Assert.Null(entry.Exception);
+ Assert.DoesNotContain("secret", entry.Message);
+ if (!timeout)
+ {
+ Assert.Equal(HttpRequestError.NameResolutionError, entry.Fields["HttpRequestError"]);
+ Assert.Equal(SocketError.HostNotFound, entry.Fields["SocketError"]);
+ }
+ }
+
+ [Fact]
+ public void UnexpectedFailure_ReportsRealStackFramesWithoutSecretMessages()
+ {
+ var exception = Assert.Throws(ThrowUnexpectedFailure);
+ var logger = new YouTubeRecordingLogger();
+
+ YouTubeDiagnostics.LogFailure(logger, exception, "BackgroundTick", "local coordination/state");
+
+ var entry = Assert.Single(logger.Entries);
+ Assert.Equal(LogLevel.Error, entry.Level);
+ Assert.Null(entry.Exception);
+ var stack = Assert.IsType(entry.Fields["SafeStackTrace"]);
+ Assert.Contains(nameof(ThrowUnexpectedFailure), stack);
+ Assert.DoesNotContain(".cs:", stack);
+ Assert.DoesNotContain("api-key-secret", entry.Message);
+ Assert.DoesNotContain("verify-token-secret", entry.Message);
+ Assert.DoesNotContain("https://", entry.Message);
+ Assert.DoesNotContain("Next subscription attempt", entry.Message);
+ Assert.DoesNotContain("polling", entry.Message);
+ Assert.Contains("worker will retry on its normal tick schedule", entry.Message);
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void ThrowUnexpectedFailure() =>
+ throw new InvalidOperationException("https://provider.example/?key=api-key-secret",
+ new Exception("verify-token-secret"));
+
+ [Fact]
+ public async Task SubscriptionUnavailable_OfflineThenLive_DiscoveryHonorsQuotaAndReportsRecovery()
+ {
+ var time = new FakeTimeProvider(DateTimeOffset.UnixEpoch);
+ var searches = 0;
+ var apiHandler = new RecordingHttpMessageHandler(_ =>
+ LiveTestHelpers.JsonResponse(++searches == 1
+ ? """{"items":[]}"""
+ : """{"items":[{"id":{"videoId":"live-video"}}]}"""));
+ var hubHandler = new RecordingHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
+ {
+ Content = new StringContent("Temporarily unavailable"),
+ });
+ var factory = new TestHttpClientFactory();
+ factory.AddClient(YouTubeClient.HttpClientName, apiHandler);
+ factory.AddClient(YouTubeClient.PubSubHttpClientName, hubHandler);
+ var options = Options();
+ var client = new YouTubeClient(factory, options, NullLogger.Instance);
+ var logger = new YouTubeRecordingLogger();
+ using var broadcaster = LiveTestHelpers.CreateBroadcaster(timeProvider: time);
+ using var service = new YouTubeWebSubService(client, broadcaster, options, logger, time,
+ new YouTubeWebSubSubscriptionState(time), new SingleInstanceLiveStatusCoordination());
+
+ await service.TickAsync(CancellationToken.None);
+ Assert.False(broadcaster.Current.YouTube.Live);
+ for (var tick = 1; tick < 15; tick++)
+ {
+ time.Advance(TimeSpan.FromMinutes(2));
+ await service.TickAsync(CancellationToken.None);
+ Assert.Equal(1, searches);
+ }
+ Assert.Equal(4, hubHandler.Requests.Count);
+ time.Advance(TimeSpan.FromMinutes(2));
+ await service.TickAsync(CancellationToken.None);
+
+ Assert.Equal(2, searches);
+ Assert.Equal(4, hubHandler.Requests.Count);
+ Assert.True(broadcaster.Current.YouTube.Live);
+ Assert.Equal("live-video", broadcaster.Current.YouTube.VideoId);
+ var warnings = logger.Entries.Where(entry => entry.Level == LogLevel.Warning).ToArray();
+ Assert.Equal(4, warnings.Length);
+ Assert.All(warnings, entry =>
+ {
+ Assert.Equal("WebSubSubscribe", entry.Fields["Operation"]);
+ Assert.Equal(503, entry.Fields["StatusCode"]);
+ Assert.True(Assert.IsType(entry.Fields["ElapsedMs"]) >= 0);
+ Assert.NotNull(entry.Fields["RetryAt"]);
+ });
+ var checks = logger.Entries.Where(entry => entry.Level == LogLevel.Information &&
+ Equals(entry.Fields["Operation"], "OfflineDiscovery")).ToArray();
+ Assert.Equal(2, checks.Length);
+ Assert.Equal(false, checks[0].Fields["LastDiscoveryLive"]);
+ Assert.Equal(DateTimeOffset.UnixEpoch, checks[0].Fields["LastSuccessfulDiscoveryAt"]);
+ Assert.Equal(true, checks[1].Fields["LastDiscoveryLive"]);
+ Assert.Equal(time.GetUtcNow(), checks[1].Fields["LastSuccessfulDiscoveryAt"]);
+ }
+
+ [Fact]
+ public async Task DiscoveryFailure_IsNotOffline_AndRetainsLastSuccessfulCheck()
+ {
+ var time = new FakeTimeProvider(DateTimeOffset.UnixEpoch);
+ var calls = 0;
+ var handler = new RecordingHttpMessageHandler(_ => ++calls != 2
+ ? LiveTestHelpers.JsonResponse("""{"items":[]}""")
+ : new HttpResponseMessage(HttpStatusCode.Forbidden)
+ {
+ Content = new StringContent("""{"error":{"errors":[{"reason":"quotaExceeded","domain":"youtube.quota"}]}}"""),
+ });
+ var factory = new TestHttpClientFactory();
+ factory.AddClient(YouTubeClient.HttpClientName, handler);
+ var options = Options(webhookSecret: "");
+ var client = new YouTubeClient(factory, options, NullLogger.Instance);
+ var logger = new YouTubeRecordingLogger();
+ using var broadcaster = LiveTestHelpers.CreateBroadcaster(timeProvider: time);
+ using var service = new YouTubeWebSubService(client, broadcaster, options, logger, time,
+ new YouTubeWebSubSubscriptionState(time), new SingleInstanceLiveStatusCoordination());
+ await service.TickAsync(CancellationToken.None);
+ time.Advance(TimeSpan.FromMinutes(30));
+
+ await Assert.ThrowsAsync(() => service.TickAsync(CancellationToken.None));
+ await service.TickAsync(CancellationToken.None);
+
+ Assert.Equal(2, calls);
+ var failure = Assert.Single(logger.Entries, entry => entry.Level == LogLevel.Warning);
+ Assert.Equal("OfflineDiscovery", failure.Fields["Operation"]);
+ Assert.Equal("quotaExceeded", failure.Fields["ProviderReason"]);
+ Assert.Equal(DateTimeOffset.UnixEpoch, failure.Fields["LastSuccessfulDiscoveryAt"]);
+ Assert.Equal(false, failure.Fields["LastDiscoveryLive"]);
+ Assert.Single(logger.Entries, entry => entry.Level == LogLevel.Information);
+
+ time.Advance(TimeSpan.FromMinutes(30));
+ await service.TickAsync(CancellationToken.None);
+ Assert.Equal(3, calls);
+ var recovered = logger.Entries.Last();
+ Assert.Equal(LogLevel.Information, recovered.Level);
+ Assert.Equal(time.GetUtcNow(), recovered.Fields["LastSuccessfulDiscoveryAt"]);
+ }
+
+ [Theory]
+ [InlineData(false)]
+ [InlineData(true)]
+ public async Task ChangedChannelSettings_ClearDiscoveryHistoryBeforeFailedResolution(bool changeConfiguredId)
+ {
+ var changed = false;
+ var searches = 0;
+ var handler = new RecordingHttpMessageHandler(request =>
+ {
+ if (changed) return new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
+ if (request.RequestUri!.AbsolutePath.EndsWith("/channels", StringComparison.Ordinal))
+ return LiveTestHelpers.JsonResponse("""{"items":[{"id":"old-channel"}]}""");
+ searches++;
+ return LiveTestHelpers.JsonResponse("""{"items":[]}""");
+ });
+ var factory = new TestHttpClientFactory();
+ factory.AddClient(YouTubeClient.HttpClientName, handler);
+ var options = Options(webhookSecret: "");
+ options.CurrentValue.YouTube.ChannelId = changeConfiguredId ? "old-channel" : "";
+ options.CurrentValue.YouTube.ChannelHandle = "@old-handle";
+ var logger = new YouTubeRecordingLogger();
+ using var broadcaster = LiveTestHelpers.CreateBroadcaster();
+ var time = new FakeTimeProvider(DateTimeOffset.UnixEpoch);
+ using var service = new YouTubeWebSubService(
+ new YouTubeClient(factory, options, NullLogger.Instance),
+ broadcaster, options, logger, time, new YouTubeWebSubSubscriptionState(time),
+ new SingleInstanceLiveStatusCoordination());
+ await service.TickAsync(CancellationToken.None);
+ var discovery = Assert.Single(logger.Entries, entry => Equals(entry.Fields["Operation"], "OfflineDiscovery"));
+ Assert.Equal(DateTimeOffset.UnixEpoch, discovery.Fields["LastSuccessfulDiscoveryAt"]);
+ Assert.Equal(false, discovery.Fields["LastDiscoveryLive"]);
+
+ changed = true;
+ if (changeConfiguredId)
+ options.CurrentValue.YouTube.ChannelId = "";
+ else
+ options.CurrentValue.YouTube.ChannelHandle = "@new-handle";
+ time.Advance(TimeSpan.FromMinutes(2));
+ await Assert.ThrowsAsync(() => service.TickAsync(CancellationToken.None));
+
+ var failure = Assert.Single(logger.Entries, entry => entry.Level == LogLevel.Warning);
+ Assert.Equal("ChannelResolution", failure.Fields["Operation"]);
+ Assert.Null(failure.Fields["LastSuccessfulDiscoveryAt"]);
+ Assert.Null(failure.Fields["LastDiscoveryLive"]);
+ Assert.Equal(1, searches);
+ }
+
+ [Theory]
+ [InlineData("ChannelResolution", YouTubeDiagnostics.ChannelsEndpoint)]
+ [InlineData("KnownVideoStatus", YouTubeDiagnostics.VideosEndpoint)]
+ [InlineData("NotificationChannelResolution", YouTubeDiagnostics.ChannelsEndpoint)]
+ [InlineData("NotificationConfirmation", YouTubeDiagnostics.SearchEndpoint)]
+ public async Task FailedChecks_IdentifyOperationAndEndpoint_WithoutChangingState(string operation, string endpoint)
+ {
+ var handler = new RecordingHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.Forbidden)
+ {
+ Content = new StringContent("""{"error":{"errors":[{"reason":"accessNotConfigured","domain":"usageLimits"}]}}"""),
+ });
+ var factory = new TestHttpClientFactory();
+ factory.AddClient(YouTubeClient.HttpClientName, handler);
+ var options = Options(webhookSecret: "");
+ if (operation.EndsWith("ChannelResolution", StringComparison.Ordinal))
+ options.CurrentValue.YouTube.ChannelId = "";
+ var client = new YouTubeClient(factory, options, NullLogger.Instance);
+ var logger = new YouTubeRecordingLogger();
+ using var broadcaster = LiveTestHelpers.CreateBroadcaster();
+ if (operation == "KnownVideoStatus")
+ broadcaster.Update(new LiveStatusUpdate { YouTube = new YouTubeStatus(true, "video") });
+ var before = broadcaster.Current;
+ using var service = new YouTubeWebSubService(client, broadcaster, options, logger,
+ new FakeTimeProvider(), new YouTubeWebSubSubscriptionState(), new SingleInstanceLiveStatusCoordination());
+
+ var exception = await Assert.ThrowsAsync(() =>
+ operation.StartsWith("Notification", StringComparison.Ordinal)
+ ? LiveStatusEndpointRouteBuilderExtensions.ConfirmYouTubeLiveStatusAsync(
+ options.CurrentValue.YouTube, client, broadcaster, logger, CancellationToken.None)
+ : service.TickAsync(CancellationToken.None));
+ YouTubeDiagnostics.LogFailure(logger, exception, "BackgroundTick", "local coordination/state", skipIfLogged: true);
+
+ Assert.Equal(before, broadcaster.Current);
+ Assert.Single(handler.Requests);
+ var failure = Assert.Single(logger.Entries);
+ Assert.Equal(operation, failure.Fields["Operation"]);
+ Assert.Equal(endpoint, failure.Fields["Endpoint"]);
+ Assert.Equal(403, failure.Fields["StatusCode"]);
+ Assert.True(Assert.IsType(failure.Fields["ElapsedMs"]) >= 0);
+ Assert.Equal("accessNotConfigured", failure.Fields["ProviderReason"]);
+ Assert.Null(failure.Exception);
+ Assert.False(failure.Fields.ContainsKey("SafeStackTrace"));
+ Assert.DoesNotContain("Next subscription attempt", failure.Message);
+ Assert.DoesNotContain("polling", failure.Message);
+ }
+
+ [Theory]
+ [InlineData(false)]
+ [InlineData(true)]
+ public async Task SubscriptionAcceptance_DoesNotReportVerifiedLeaseEvenIfPersistenceFails(bool failPersistence)
+ {
+ var factory = new TestHttpClientFactory();
+ factory.AddClient(YouTubeClient.HttpClientName,
+ new RecordingHttpMessageHandler(_ => LiveTestHelpers.JsonResponse("""{"items":[]}""")));
+ factory.AddClient(YouTubeClient.PubSubHttpClientName,
+ new RecordingHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.Accepted)));
+ var options = Options();
+ var logger = new YouTubeRecordingLogger();
+ var time = new FakeTimeProvider(DateTimeOffset.UnixEpoch);
+ var state = new YouTubeWebSubSubscriptionState(time)
+ {
+ MarkRequestSentException = failPersistence ? new IOException("State persistence failed") : null,
+ };
+ using var broadcaster = LiveTestHelpers.CreateBroadcaster();
+ using var service = new YouTubeWebSubService(
+ new YouTubeClient(factory, options, NullLogger.Instance),
+ broadcaster, options, logger, time, state, new SingleInstanceLiveStatusCoordination());
+
+ if (failPersistence)
+ {
+ var failure = await Assert.ThrowsAsync(() => service.TickAsync(CancellationToken.None));
+ Assert.Same(state.MarkRequestSentException, failure);
+ }
+ else
+ {
+ await service.TickAsync(CancellationToken.None);
+ }
+
+ var accepted = Assert.Single(logger.Entries, entry => Equals(entry.Fields["Operation"], "WebSubSubscribe"));
+ Assert.Equal(LogLevel.Information, accepted.Level);
+ Assert.Equal(time.GetUtcNow(), accepted.Fields["AcceptedAt"]);
+ Assert.True(Assert.IsType(accepted.Fields["ElapsedMs"]) >= 0);
+ Assert.Contains("HTTP acceptance does not establish a verified lease", accepted.Message);
+ Assert.Equal(DateTimeOffset.MinValue, await state.GetRenewAtAsync());
+ }
+
+ private static TestOptionsMonitor Options(string webhookSecret = "secret") =>
+ new(new LiveStatusOptions
+ {
+ PublicBaseUrl = "https://example.com",
+ YouTube = new YouTubeOptions { ApiKey = "api-key", ChannelId = "channel", WebhookSecret = webhookSecret },
+ });
+
+ private sealed class UnreadableStream : MemoryStream
+ {
+ public override ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) =>
+ ValueTask.FromException(new IOException("key=secret"));
+ }
+}
+
+internal sealed class YouTubeRecordingLogger : ILogger
+{
+ internal sealed record Entry(LogLevel Level, Exception? Exception, string Message, Dictionary Fields);
+ public List Entries { get; } = [];
+ public IDisposable? BeginScope(TState state) where TState : notnull => null;
+ public bool IsEnabled(LogLevel logLevel) => true;
+ public void Log(LogLevel logLevel, EventId eventId, TState state,
+ Exception? exception, Func formatter) =>
+ Entries.Add(new(logLevel, exception, formatter(state, exception),
+ ((IEnumerable>)state!).ToDictionary(pair => pair.Key, pair => pair.Value)));
+}
diff --git a/tests/StaticHost.Tests/Live/YouTubeWebSubServiceTests.cs b/tests/StaticHost.Tests/Live/YouTubeWebSubServiceTests.cs
index 502740134..393a66ec8 100644
--- a/tests/StaticHost.Tests/Live/YouTubeWebSubServiceTests.cs
+++ b/tests/StaticHost.Tests/Live/YouTubeWebSubServiceTests.cs
@@ -370,14 +370,14 @@ public async Task TickAsync_BacksOffSubscriptionsWithoutStoppingLivePolling(stri
if (failureKind == "unexpected")
{
Assert.Equal(LogLevel.Error, report.Level);
- Assert.Same(failure, report.Exception);
+ Assert.Null(report.Exception);
}
else
{
Assert.Equal(LogLevel.Warning, report.Level);
Assert.Null(report.Exception);
Assert.Contains("Next subscription attempt", report.Message, StringComparison.Ordinal);
- Assert.Contains(logger.Entries, entry => entry.Level == LogLevel.Debug && entry.Exception == failure);
+ Assert.DoesNotContain(logger.Entries, entry => entry.Exception is not null);
}
time.Advance(TimeSpan.FromMinutes(2));