// Integration tests — require live network (DDG/Bing/etc.)
// Run with: LIVE=1 node --test tests/integration.test.mjs
// These tests will fail if providers return 0 results due to broken parsers,
// proving the plugin is not "constantly throwing 0 results".
import { describe, it, before } from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
const require = createRequire(import.meta.url);
const { toolsProvider } = require('../toolsProvider.js');

const shouldRunLive = !!process.env.LIVE || !!process.env.CI_LIVE;
const liveOrSkip = shouldRunLive ? describe : describe.skip;

function makeMockCtl(overrides = {}) {
  const defaults = {
    maxSearchResults: 5,
    maxPagesPerSearch: 2,
    fetchTimeoutMs: 8000,
    searchIntervalMs: 7000, // safe default — matches plugin default (7000), avoids rate limit out-of-the-box
    enableSearxng: false,
    enableDDG: true,
    enableDDGLite: true,
    enableBrave: true,
    enableBing: true,
    enableGoogle: false,
    enableEcosia: false,
    enableStartpage: true,
    enableYandex: false,
    enableYahoo: false,
    enableBaidu: false,
    userAgents: [
      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    ].join("\n"),
    defaultLanguage: "en-us",
    searxngUrl: "",
    searchRecencyWindow: "any",
    lmStudioUrl: "",
  };
  const values = { ...defaults, ...overrides };
  return {
    getPluginConfig: () => ({
      get: (key) => {
        if (!(key in values)) throw new Error(`unknown config key ${key}`);
        return values[key];
      },
    }),
  };
}

function mockCtx(timeoutMs = 30000) {
  return {
    signal: AbortSignal.timeout(timeoutMs),
    status: (msg) => console.log(`[integration status] ${msg}`),
  };
}

liveOrSkip('live: core search tools', async () => {
  // Small delay before each live search to respect rate limiter and avoid false blocks
  // Must be >= searchIntervalMs (7000) to avoid out-of-the-box rate limiting
  const liveDelay = () => new Promise(r => setTimeout(r, 7500));

  it('search "python programming language" returns >0 results and reads pages', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'python programming language', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('search result:', JSON.stringify({ total: res.total_results_found, pages: res.pages_read, diags: res.search_diagnostics }, null, 2));
    // If temporarily blocked, verify that the plugin correctly reports bot protection (not silent 0)
    // This is not a parser failure — it's expected anti-bot behavior under load
    if (res.total_results_found === 0) {
      const isBotBlock = res.search_diagnostics.some(d => {
        const e = (d.error || '').toLowerCase();
        return e.includes('bot') || e.includes('blocked') || e.includes('captcha') || e.includes('challenge');
      });
      assert.ok(isBotBlock, `0 results should be accompanied by clear bot-block diagnostic, got ${JSON.stringify(res.search_diagnostics)}`);
      console.warn('Live test: DDG temporarily blocked (expected under load) — plugin correctly reported block, not silent failure. Consider this a soft pass.');
      return;
    }
    assert.ok(res.total_results_found > 0, `expected >0 results, got ${res.total_results_found} — parser may be broken`);
    assert.ok(res.pages_read > 0, `expected >0 pages_read, got ${res.pages_read} — fetchPage may be broken`);
    assert.ok(res.search_diagnostics.length >= 1, 'should have at least 1 diagnostic');
    // Disabled providers must NOT appear
    const disabled = ['bing', 'startpage', 'google', 'ecosia', 'yandex', 'yahoo', 'baidu', 'searxng', 'ddgLite', 'brave'].filter(b => res.search_diagnostics.some(d => d.backend === b));
    assert.equal(disabled.length, 0, `disabled providers should not be in diagnostics, found ${disabled}`);
    // Check that page content is non-empty
    const firstContent = res.pages_read_content?.[0]?.content;
    assert.ok(firstContent && firstContent.length > 200, 'first page content should be substantial (>200 chars)');
  });

  it('search "captcha solving methods" does not falsely trigger DDG captcha (false-positive regression)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'captcha solving methods accessibility', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('captcha query diagnostics:', res.search_diagnostics);
    // Should NOT be flagged as captcha — the old bug caused this to return 0 with captcha error
    const isBlocked = res.search_diagnostics.some(d => (d.error || '').toLowerCase().includes('bot') && res.total_results_found === 0);
    if (isBlocked) {
      // Could be real temporary block, not false positive from snippet. Retry once with slightly different query
      console.log('First captcha query blocked (may be real temporary block), retrying after 5s...');
      await new Promise(r => setTimeout(r, 5000));
      const raw2 = await search.implementation({ query: 'captcha solving methods accessibility wcag', max_pages_to_read: 1 }, mockCtx());
      const res2 = JSON.parse(raw2);
      console.log('retry result:', res2.total_results_found, res2.search_diagnostics);
      if (res2.total_results_found === 0) {
        const isBot2 = res2.search_diagnostics.some(d => (d.error||'').toLowerCase().includes('bot'));
        assert.ok(isBot2, 'if both blocked, should be reported as bot block (not silent 0)');
        console.warn('Both captcha queries blocked — likely temporary IP rate limit, not false-positive bug. Soft pass.');
        return;
      }
      assert.ok(res2.total_results_found > 0, 'retry should succeed if first was real block, not systematic false positive');
      return;
    }
    assert.ok(res.total_results_found > 0, 'captcha query should return results');
  });

  it('fetch_and_read python.org returns content', async () => {
    await liveDelay();
    const ctl = makeMockCtl();
    const tools = await toolsProvider(ctl);
    const fetchTool = tools.find(t => t.name === 'fetch_and_read');
    const raw = await fetchTool.implementation({ url: 'https://www.python.org/', max_chars: 4000 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('fetch_and_read result:', res.title, res.word_count);
    assert.ok(!res.error, `fetch_and_read should not error: ${res.error}`);
    assert.ok(res.word_count > 10, `expected >10 words, got ${res.word_count}`);
    assert.ok(res.content && res.content.includes('Python'), 'content should mention Python');
  });

  it('disabled providers do not trigger fetch or diagnostics (token saving)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableGoogle: false, enableStartpage: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'test token saving query', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    const backends = res.search_diagnostics.map(d => d.backend);
    console.log('token saving backends:', backends);
    assert.ok(!backends.includes('bing'), 'bing disabled should not be in diagnostics');
    assert.ok(!backends.includes('google'), 'google disabled should not be in diagnostics');
    assert.ok(!backends.includes('startpage'), 'startpage disabled should not be in diagnostics');
    assert.ok(backends.includes('ddg'), 'enabled ddg should be in diagnostics');
    // Ensure we didn't waste tokens with 9 entries
    assert.ok(res.search_diagnostics.length <= 2, `should have <=2 diagnostics for single-provider success, got ${res.search_diagnostics.length}`);
  });

  it('all providers disabled returns single "none" diagnostic', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: false, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false, enableGoogle: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'anything', max_pages_to_read: 1 }, mockCtx(5000));
    const res = JSON.parse(raw);
    console.log('all disabled diagnostics:', res.search_diagnostics);
    assert.equal(res.search_diagnostics.length, 1);
    assert.equal(res.search_diagnostics[0].backend, 'none');
    assert.ok(res.search_diagnostics[0].error.includes('No search providers enabled'));
  });

  it('Bing-only search either succeeds or reports clear bot block (not silent empty)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: false, enableDDGLite: false, enableBrave: false, enableBing: true, enableStartpage: false, enableGoogle: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'python programming language', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('Bing-only result:', res.total_results_found, res.search_diagnostics);
    if (res.total_results_found === 0) {
      // Should have a clear bot challenge / no-results block message, not generic empty
      const err = res.search_diagnostics[0]?.error || '';
      assert.ok(err.toLowerCase().includes('bot') || err.toLowerCase().includes('no results') || err.includes('Bing'), `Bing failure should be explicit bot challenge, got: ${err}`);
    } else {
      assert.ok(res.pages_read > 0, 'if Bing succeeds, pages_read should be >0');
    }
  });
});

liveOrSkip('live: multi-angle tools', async () => {
  const liveDelay = () => new Promise(r => setTimeout(r, 7500));
  it('deep_search with 2 angles returns results (fallback not needed)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const deep = tools.find(t => t.name === 'deep_search');
    const raw = await deep.implementation({ topic: 'quantum computing', angles: ['benefits', 'risks'], pages_per_angle: 1 }, mockCtx(60000));
    const res = JSON.parse(raw);
    console.log('deep_search diagnostics:', res.search_diagnostics);
    assert.ok(res.results.length === 2);
    // Each angle should have either hits or clear error, but not 0 hits with no diagnostics
    // Allow temporary blocks — as long as diagnostics clearly report block, not silent 0
    assert.ok(res.search_diagnostics.length >= 2, 'should have diagnostics per angle');
    const allowed = ['ddg'];
    const disabledInDiags = res.search_diagnostics.filter(d => !allowed.includes(d.backend));
    assert.equal(disabledInDiags.length, 0, `only ddg should appear when only ddg enabled, found: ${JSON.stringify(disabledInDiags.map(d=>d.backend))}`);
  });

  it('fact_check 4 angles does not waste tokens on disabled providers', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const fact = tools.find(t => t.name === 'fact_check');
    const raw = await fact.implementation({ claim: 'The Earth is flat' }, mockCtx(60000));
    const res = JSON.parse(raw);
    console.log('fact_check diagnostics count:', res.search_diagnostics.length, res.search_diagnostics.map(d=>d.backend));
    // 4 angles × 1 enabled provider = 4 diagnostics max if all succeed on DDG
    // If some DDG blocks, it may fallback but still only enabled providers
    assert.ok(res.search_diagnostics.length <= 8, `should be <=8 (4 angles × 2 fallbacks), got ${res.search_diagnostics.length}`);
    const allowed2 = ['ddg'];
    const disabled2 = res.search_diagnostics.filter(d => !allowed2.includes(d.backend));
    assert.equal(disabled2.length, 0, `only ddg should appear when only ddg enabled, found ${JSON.stringify(disabled2.map(d=>d.backend))}`);
  });
});

// Integration tests — require live network (DDG/Bing/etc.)
// Run with: LIVE=1 node --test tests/integration.test.mjs
// These tests will fail if providers return 0 results due to broken parsers,
// proving the plugin is not "constantly throwing 0 results".
import { describe, it, before } from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
const require = createRequire(import.meta.url);
const { toolsProvider } = require('../toolsProvider.js');

const shouldRunLive = !!process.env.LIVE || !!process.env.CI_LIVE;
const liveOrSkip = shouldRunLive ? describe : describe.skip;

function makeMockCtl(overrides = {}) {
  const defaults = {
    maxSearchResults: 5,
    maxPagesPerSearch: 2,
    fetchTimeoutMs: 8000,
    searchIntervalMs: 7000, // safe default — matches plugin default (7000), avoids rate limit out-of-the-box
    enableSearxng: false,
    enableDDG: true,
    enableDDGLite: true,
    enableBrave: true,
    enableBing: true,
    enableGoogle: false,
    enableEcosia: false,
    enableStartpage: true,
    enableYandex: false,
    enableYahoo: false,
    enableBaidu: false,
    userAgents: [
      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    ].join("\n"),
    defaultLanguage: "en-us",
    searxngUrl: "",
    searchRecencyWindow: "any",
    lmStudioUrl: "",
  };
  const values = { ...defaults, ...overrides };
  return {
    getPluginConfig: () => ({
      get: (key) => {
        if (!(key in values)) throw new Error(`unknown config key ${key}`);
        return values[key];
      },
    }),
  };
}

function mockCtx(timeoutMs = 30000) {
  return {
    signal: AbortSignal.timeout(timeoutMs),
    status: (msg) => console.log(`[integration status] ${msg}`),
  };
}

liveOrSkip('live: core search tools', async () => {
  // Small delay before each live search to respect rate limiter and avoid false blocks
  // Must be >= searchIntervalMs (7000) to avoid out-of-the-box rate limiting
  const liveDelay = () => new Promise(r => setTimeout(r, 7500));

  it('search "python programming language" returns >0 results and reads pages', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'python programming language', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('search result:', JSON.stringify({ total: res.total_results_found, pages: res.pages_read, diags: res.search_diagnostics }, null, 2));
    // If temporarily blocked, verify that the plugin correctly reports bot protection (not silent 0)
    // This is not a parser failure — it's expected anti-bot behavior under load
    if (res.total_results_found === 0) {
      const isBotBlock = res.search_diagnostics.some(d => {
        const e = (d.error || '').toLowerCase();
        return e.includes('bot') || e.includes('blocked') || e.includes('captcha') || e.includes('challenge');
      });
      assert.ok(isBotBlock, `0 results should be accompanied by clear bot-block diagnostic, got ${JSON.stringify(res.search_diagnostics)}`);
      console.warn('Live test: DDG temporarily blocked (expected under load) — plugin correctly reported block, not silent failure. Consider this a soft pass.');
      return;
    }
    assert.ok(res.total_results_found > 0, `expected >0 results, got ${res.total_results_found} — parser may be broken`);
    assert.ok(res.pages_read > 0, `expected >0 pages_read, got ${res.pages_read} — fetchPage may be broken`);
    assert.ok(res.search_diagnostics.length >= 1, 'should have at least 1 diagnostic');
    // Disabled providers must NOT appear
    const disabled = ['bing', 'startpage', 'google', 'ecosia', 'yandex', 'yahoo', 'baidu', 'searxng', 'ddgLite', 'brave'].filter(b => res.search_diagnostics.some(d => d.backend === b));
    assert.equal(disabled.length, 0, `disabled providers should not be in diagnostics, found ${disabled}`);
    // Check that page content is non-empty
    const firstContent = res.pages_read_content?.[0]?.content;
    assert.ok(firstContent && firstContent.length > 200, 'first page content should be substantial (>200 chars)');
  });

  it('search "captcha solving methods" does not falsely trigger DDG captcha (false-positive regression)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'captcha solving methods accessibility', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('captcha query diagnostics:', res.search_diagnostics);
    // Should NOT be flagged as captcha — the old bug caused this to return 0 with captcha error
    const isBlocked = res.search_diagnostics.some(d => (d.error || '').toLowerCase().includes('bot') && res.total_results_found === 0);
    if (isBlocked) {
      // Could be real temporary block, not false positive from snippet. Retry once with slightly different query
      console.log('First captcha query blocked (may be real temporary block), retrying after 5s...');
      await new Promise(r => setTimeout(r, 5000));
      const raw2 = await search.implementation({ query: 'captcha solving methods accessibility wcag', max_pages_to_read: 1 }, mockCtx());
      const res2 = JSON.parse(raw2);
      console.log('retry result:', res2.total_results_found, res2.search_diagnostics);
      if (res2.total_results_found === 0) {
        const isBot2 = res2.search_diagnostics.some(d => (d.error||'').toLowerCase().includes('bot'));
        assert.ok(isBot2, 'if both blocked, should be reported as bot block (not silent 0)');
        console.warn('Both captcha queries blocked — likely temporary IP rate limit, not false-positive bug. Soft pass.');
        return;
      }
      assert.ok(res2.total_results_found > 0, 'retry should succeed if first was real block, not systematic false positive');
      return;
    }
    assert.ok(res.total_results_found > 0, 'captcha query should return results');
  });

  it('fetch_and_read python.org returns content', async () => {
    await liveDelay();
    const ctl = makeMockCtl();
    const tools = await toolsProvider(ctl);
    const fetchTool = tools.find(t => t.name === 'fetch_and_read');
    const raw = await fetchTool.implementation({ url: 'https://www.python.org/', max_chars: 4000 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('fetch_and_read result:', res.title, res.word_count);
    assert.ok(!res.error, `fetch_and_read should not error: ${res.error}`);
    assert.ok(res.word_count > 10, `expected >10 words, got ${res.word_count}`);
    assert.ok(res.content && res.content.includes('Python'), 'content should mention Python');
  });

  it('disabled providers do not trigger fetch or diagnostics (token saving)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableGoogle: false, enableStartpage: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'test token saving query', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    const backends = res.search_diagnostics.map(d => d.backend);
    console.log('token saving backends:', backends);
    assert.ok(!backends.includes('bing'), 'bing disabled should not be in diagnostics');
    assert.ok(!backends.includes('google'), 'google disabled should not be in diagnostics');
    assert.ok(!backends.includes('startpage'), 'startpage disabled should not be in diagnostics');
    assert.ok(backends.includes('ddg'), 'enabled ddg should be in diagnostics');
    // Ensure we didn't waste tokens with 9 entries
    assert.ok(res.search_diagnostics.length <= 2, `should have <=2 diagnostics for single-provider success, got ${res.search_diagnostics.length}`);
  });

  it('all providers disabled returns single "none" diagnostic', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: false, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false, enableGoogle: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'anything', max_pages_to_read: 1 }, mockCtx(5000));
    const res = JSON.parse(raw);
    console.log('all disabled diagnostics:', res.search_diagnostics);
    assert.equal(res.search_diagnostics.length, 1);
    assert.equal(res.search_diagnostics[0].backend, 'none');
    assert.ok(res.search_diagnostics[0].error.includes('No search providers enabled'));
  });

  it('Bing-only search either succeeds or reports clear bot block (not silent empty)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: false, enableDDGLite: false, enableBrave: false, enableBing: true, enableStartpage: false, enableGoogle: false, enableEcosia: false });
    const tools = await toolsProvider(ctl);
    const search = tools.find(t => t.name === 'search');
    const raw = await search.implementation({ query: 'python programming language', max_pages_to_read: 1 }, mockCtx());
    const res = JSON.parse(raw);
    console.log('Bing-only result:', res.total_results_found, res.search_diagnostics);
    if (res.total_results_found === 0) {
      // Should have a clear bot challenge / no-results block message, not generic empty
      const err = res.search_diagnostics[0]?.error || '';
      assert.ok(err.toLowerCase().includes('bot') || err.toLowerCase().includes('no results') || err.includes('Bing'), `Bing failure should be explicit bot challenge, got: ${err}`);
    } else {
      assert.ok(res.pages_read > 0, 'if Bing succeeds, pages_read should be >0');
    }
  });
});

liveOrSkip('live: multi-angle tools', async () => {
  const liveDelay = () => new Promise(r => setTimeout(r, 7500));
  it('deep_search with 2 angles returns results (fallback not needed)', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const deep = tools.find(t => t.name === 'deep_search');
    const raw = await deep.implementation({ topic: 'quantum computing', angles: ['benefits', 'risks'], pages_per_angle: 1 }, mockCtx(60000));
    const res = JSON.parse(raw);
    console.log('deep_search diagnostics:', res.search_diagnostics);
    assert.ok(res.results.length === 2);
    // Each angle should have either hits or clear error, but not 0 hits with no diagnostics
    // Allow temporary blocks — as long as diagnostics clearly report block, not silent 0
    assert.ok(res.search_diagnostics.length >= 2, 'should have diagnostics per angle');
    const allowed = ['ddg'];
    const disabledInDiags = res.search_diagnostics.filter(d => !allowed.includes(d.backend));
    assert.equal(disabledInDiags.length, 0, `only ddg should appear when only ddg enabled, found: ${JSON.stringify(disabledInDiags.map(d=>d.backend))}`);
  });

  it('fact_check 4 angles does not waste tokens on disabled providers', async () => {
    await liveDelay();
    const ctl = makeMockCtl({ enableDDG: true, enableDDGLite: false, enableBrave: false, enableBing: false, enableStartpage: false });
    const tools = await toolsProvider(ctl);
    const fact = tools.find(t => t.name === 'fact_check');
    const raw = await fact.implementation({ claim: 'The Earth is flat' }, mockCtx(60000));
    const res = JSON.parse(raw);
    console.log('fact_check diagnostics count:', res.search_diagnostics.length, res.search_diagnostics.map(d=>d.backend));
    // 4 angles × 1 enabled provider = 4 diagnostics max if all succeed on DDG
    // If some DDG blocks, it may fallback but still only enabled providers
    assert.ok(res.search_diagnostics.length <= 8, `should be <=8 (4 angles × 2 fallbacks), got ${res.search_diagnostics.length}`);
    const allowed2 = ['ddg'];
    const disabled2 = res.search_diagnostics.filter(d => !allowed2.includes(d.backend));
    assert.equal(disabled2.length, 0, `only ddg should appear when only ddg enabled, found ${JSON.stringify(disabled2.map(d=>d.backend))}`);
  });
});