templates/test_suite/test_suite.html.twig line 1

Open in your IDE?
  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>{{ site_name }}</title>
  6.     <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 128 128%22><text y=%221.2em%22 font-size=%2296%22>⚫️</text></svg>">
  7.     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.6.1/dist/css/bootstrap.min.css"
  8.           integrity="sha384-zCbKRCUGaJDkqS1kPbPd7TveP5iyJE0EjAuZQTgFLD2ylzuqKfdKlfG/eSrtxUkn" crossorigin="anonymous">
  9.     <script src="https://cdn.jsdelivr.net/npm/jquery@3.5.1/dist/jquery.slim.min.js"
  10.             integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj"
  11.             crossorigin="anonymous"></script>
  12.     <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.6.1/dist/js/bootstrap.bundle.min.js"
  13.             integrity="sha384-fQybjgWLrvvRgtW6bFlB7jaZrFsaBXjsOMm/tB9LTS58ONXgqbR9W8oWht/amnpF"
  14.             crossorigin="anonymous"></script>
  16.     <script>
  17.         window.axeptioSettings = {
  18.             clientId: "66137db6ae83de5e566cfc53",
  19.             cookiesVersion: "first-id sandbox-fr-EU",
  20.         };
  22.         (function (d, s) {
  23.             var t = d.getElementsByTagName(s)[0],
  24.                 e = d.createElement(s);
  25.             e.async = false;
  26.             e.src = "//static.axept.io/tcf/sdk.js";
  27.             e.type = "module";
  28.             t.parentNode.insertBefore(e, t);
  29.         })(document, "script");
  30.     </script>
  32.     <style>
  33.         .test-card {
  34.             border: 2px solid #dee2e6;
  35.             border-radius: 8px;
  36.             padding: 20px;
  37.             margin-bottom: 20px;
  38.             transition: background-color 0.3s ease;
  39.         }
  40.         .test-card.success { background-color: #d4edda; border-color: #28a745; }
  41.         .test-card.error { background-color: #f8d7da; border-color: #dc3545; }
  42.         .test-card.running { background-color: #fff3cd; border-color: #ffc107; }
  43.         .test-card.disabled { opacity: 0.5; pointer-events: none; }
  44.         .log-output {
  45.             background-color: #f8f9fa;
  46.             border: 1px solid #dee2e6;
  47.             border-radius: 4px;
  48.             padding: 10px;
  49.             max-height: 300px;
  50.             overflow-y: auto;
  51.             font-family: monospace;
  52.             font-size: 12px;
  53.             white-space: pre-wrap;
  54.             word-break: break-all;
  55.         }
  56.         .log-entry { margin-bottom: 5px; }
  57.         .log-entry.error { color: #dc3545; font-weight: bold; }
  58.         .log-entry.debug { color: #007bff; }
  59.         .log-entry.info { color: #28a745; }
  60.         iframe { width: 100%; height: 400px; border: 1px solid #dee2e6; border-radius: 4px; }
  61.         #globalSummary { display: none; }
  62.         #globalSummary.visible { display: block; }
  63.     </style>
  64. </head>
  65. <body>
  66. <nav class="navbar navbar-expand-lg navbar-light bg-light">
  67.     <a class="navbar-brand" href="{{ path('app_index') }}">{{ site_name }}</a>
  68. </nav>
  70. <div class="container mt-4">
  71.     <div class="row mb-3">
  72.         <div class="col-md-12">
  73.             <label for="environmentSelect" class="font-weight-bold">Environnement API</label>
  74.             <select id="environmentSelect" class="form-control form-control-lg" style="max-width: 400px;">
  75.                 <option value="preprod" selected>Preprod — api.preprod.first-id.fr</option>
  76.                 <option value="prod">Prod — api.first-id.fr</option>
  77.             </select>
  78.         </div>
  79.     </div>
  80.     <div class="row">
  81.         <div class="col-md-12">
  82.             <h1>Suite de Tests Complète</h1>
  83.             <p class="lead">Validation automatique de toutes les APIs FirstID</p>
  84.             <button id="startAllTests" class="btn btn-primary btn-lg mb-4">Démarrer tous les tests</button>
  85.         </div>
  86.     </div>
  88.     <div id="globalSummary" class="alert mb-4">
  89.         <h4 id="summaryTitle"></h4>
  90.         <p id="summaryDetails"></p>
  91.         <p id="summaryDuration"></p>
  92.     </div>
  94.     <div class="row">
  95.         <div class="col-md-12">
  96.             <div id="test1" class="test-card">
  97.                 <h3>Test 1: Premier chargement du SDK</h3>
  98.                 <p>Suppression des cookies et chargement initial du SDK</p>
  99.                 <div class="test-status"><span class="badge badge-secondary" id="test1-status">En attente</span></div>
  100.                 <div class="mt-3"><button class="btn btn-sm btn-primary" onclick="runTest1()">Exécuter Test 1</button></div>
  101.                 <div class="log-output mt-3" id="test1-log"></div>
  102.             </div>
  104.             <div id="test2" class="test-card">
  105.                 <h3>Test 2: Rechargement du SDK</h3>
  106.                 <p>Rechargement du SDK sans suppression des cookies</p>
  107.                 <div class="test-status"><span class="badge badge-secondary" id="test2-status">En attente</span></div>
  108.                 <div class="mt-3">
  109.                     <button class="btn btn-sm btn-primary" onclick="runTest2()">Exécuter Test 2</button>
  110.                     <span class="badge badge-warning ml-2">Nécessite un first id (ou Test 1)</span>
  111.                 </div>
  112.                 <div class="log-output mt-3" id="test2-log"></div>
  113.             </div>
  115.             <div id="test3" class="test-card">
  116.                 <h3>Test 3: Appels APP API</h3>
  117.                 <p>Tests des appels APP API</p>
  118.                 <div class="test-status"><span class="badge badge-secondary" id="test3-status">En attente</span></div>
  119.                 <div class="mt-3"><button class="btn btn-sm btn-primary" onclick="runTest3()">Exécuter Test 3</button></div>
  120.                 <div class="log-output mt-3" id="test3-log"></div>
  121.             </div>
  123.             <div id="test4" class="test-card">
  124.                 <h3>Test 4: Redirection Gate</h3>
  125.                 <p>Test de la redirection vers la gate dans une iframe (page dédiée)</p>
  126.                 <div class="test-status"><span class="badge badge-secondary" id="test4-status">En attente</span></div>
  127.                 <div class="mt-3"><button class="btn btn-sm btn-primary" onclick="runTest4()">Exécuter Test 4</button></div>
  128.                 <div class="log-output mt-3" id="test4-log"></div>
  129.                 <div class="mt-3" id="test4-iframe-container"></div>
  130.             </div>
  132.             <div id="test5" class="test-card">
  133.                 <h3>Test 5: SDK Premium Lite dans iframe</h3>
  134.                 <p>Test du SDK Premium Lite chargé dans une iframe dédiée</p>
  135.                 <div class="test-status"><span class="badge badge-secondary" id="test5-status">En attente</span></div>
  136.                 <div class="mt-3"><button class="btn btn-sm btn-primary" onclick="runTest5()">Exécuter Test 5</button></div>
  137.                 <div class="log-output mt-3" id="test5-log"></div>
  138.                 <div class="mt-3" id="test5-iframe-container"></div>
  139.             </div>
  141.             <div id="test6" class="test-card">
  142.                 <h3>Test 6: Email hashé</h3>
  143.                 <p>Test de l'ajout d'un email hashé via le SDK</p>
  144.                 <div class="test-status"><span class="badge badge-secondary" id="test6-status">En attente</span></div>
  145.                 <div class="mt-3">
  146.                     <button class="btn btn-sm btn-primary" onclick="runTest6()">Exécuter Test 6</button>
  147.                     <span class="badge badge-warning ml-2">Nécessite un SDK chargé (ou Test 1)</span>
  148.                 </div>
  149.                 <div class="log-output mt-3" id="test6-log"></div>
  150.             </div>
  152.             <div id="test7" class="test-card">
  153.                 <h3>Test 7: setCustomData avec cxenseid</h3>
  154.                 <p>Test de l'ajout de customData (cxenseid) et récupération du firstId après suppression des cookies</p>
  155.                 <div class="test-status"><span class="badge badge-secondary" id="test7-status">En attente</span></div>
  156.                 <div class="mt-3">
  157.                     <button class="btn btn-sm btn-primary" onclick="runTest7()">Exécuter Test 7</button>
  158.                     <span class="badge badge-warning ml-2">Nécessite un SDK chargé (ou Test 1)</span>
  159.                 </div>
  160.                 <div class="log-output mt-3" id="test7-log"></div>
  161.             </div>
  163.             <div id="test8" class="test-card">
  164.                 <h3>Test 8: getDeviceId et getFirstIdEidsObject</h3>
  165.                 <p>Test de récupération du deviceId et de l'objet eids pour Prebid.js</p>
  166.                 <div class="test-status"><span class="badge badge-secondary" id="test8-status">En attente</span></div>
  167.                 <div class="mt-3">
  168.                     <button class="btn btn-sm btn-primary" onclick="runTest8()">Exécuter Test 8</button>
  169.                     <span class="badge badge-warning ml-2">Nécessite un SDK chargé (ou Test 1)</span>
  170.                 </div>
  171.                 <div class="log-output mt-3" id="test8-log"></div>
  172.             </div>
  174.             <div id="test9" class="test-card">
  175.                 <h3>Test 9: getMasterFirstId</h3>
  176.                 <p>Test de récupération du master firstId depuis un slave firstId</p>
  177.                 <div class="test-status"><span class="badge badge-secondary" id="test9-status">En attente</span></div>
  178.                 <div class="mt-3">
  179.                     <button class="btn btn-sm btn-primary" onclick="runTest9()">Exécuter Test 9</button>
  180.                     <span class="badge badge-info ml-2">Prépare automatiquement les données</span>
  181.                 </div>
  182.                 <div class="log-output mt-3" id="test9-log"></div>
  183.             </div>
  184.         </div>
  185.     </div>
  186. </div>
  188. <script>
  189.     const COOKIES_TO_DELETE = [
  190.         'firstid', 'firstid_flex_type', 'fid_email_hashed', 'fid_email_hash',
  191.         'fidsdk_consent', 'fid_customdata_hash', 'fidflexlastsync',
  192.         'fidflexemaillastsync', 'firstid_refresh', 'fidflexlastcheck'
  193.     ];
  194.     const SDK_LOAD_TIMEOUT_MS = 5000;
  195.     const IFRAME_TIMEOUT_MS = 20000;
  196.     const FIRSTID_VENDOR_ID = 1178;
  197.     const MAID_MATCHING_API_PROXY_URL = '/test-suite/api-proxy';
  198.     const TOTAL_TESTS = 9;
  200.     const API_PREPROD_BASE = 'https://api.preprod.first-id.fr';
  201.     const API_PROD_BASE = 'https://api.first-id.fr';
  202.     const CDN_PREPROD_BASE = 'https://cdn.preprod.first-id.fr';
  203.     const CDN_PROD_BASE = 'https://cdn.first-id.fr';
  204.     const DELETE_FG_PREPROD_V4 = 'https://api-v4.preprod.first-id.fr/fg';
  205.     const DELETE_FG_PREPROD_V6 = 'https://api-v6.preprod.first-id.fr/fg';
  207.     let testState = {};
  208.     let originalConsoleDebug = console.debug;
  209.     let originalConsoleError = console.error;
  210.     let consoleInterceptActive = false;
  211.     let interceptedErrors = [];
  213.     function resetTestState() {
  214.         testState = {
  215.             results: {},
  216.             hasConsent: false,
  217.             suiteStartTime: null
  218.         };
  219.     }
  221.     resetTestState();
  223.     function getSelectedEnvironment() {
  224.         const select = document.getElementById('environmentSelect');
  225.         return select && select.value === 'prod' ? 'prod' : 'preprod';
  226.     }
  228.     function getApiBaseUrl() {
  229.         return getSelectedEnvironment() === 'prod' ? API_PROD_BASE : API_PREPROD_BASE;
  230.     }
  232.     function getCdnBaseUrl() {
  233.         return getSelectedEnvironment() === 'prod' ? CDN_PROD_BASE : CDN_PREPROD_BASE;
  234.     }
  236.     function getCdnLoaderFlexUrl() {
  237.         return getCdnBaseUrl() + '/sdk/loader/loader-latest-flex.js?id=1234567890';
  238.     }
  240.     function getCdnLoaderPremiumLiteUrl() {
  241.         return getCdnBaseUrl() + '/sdk/loader/loader-latest-premium-lite.js?id=1234567890';
  242.     }
  244.     function setupConsoleInterceptor(testNumber) {
  245.         interceptedErrors = [];
  246.         consoleInterceptActive = true;
  248.         console.debug = function (...args) {
  249.             if (consoleInterceptActive) {
  250.                 logToTest(testNumber, 'debug', '[DEBUG] ' + args.join(' '));
  251.             }
  252.             originalConsoleDebug.apply(console, args);
  253.         };
  255.         console.error = function (...args) {
  256.             if (consoleInterceptActive) {
  257.                 interceptedErrors.push(args.join(' '));
  258.                 logToTest(testNumber, 'error', '[ERROR] ' + args.join(' '));
  259.             }
  260.             originalConsoleError.apply(console, args);
  261.         };
  262.     }
  264.     function teardownConsoleInterceptor() {
  265.         consoleInterceptActive = false;
  266.         console.debug = originalConsoleDebug;
  267.         console.error = originalConsoleError;
  268.     }
  270.     function logToTest(testNumber, level, message) {
  271.         const logElement = document.getElementById(`test${testNumber}-log`);
  272.         if (!logElement) return;
  273.         const entry = document.createElement('div');
  274.         entry.className = `log-entry ${level}`;
  275.         entry.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
  276.         logElement.appendChild(entry);
  277.         logElement.scrollTop = logElement.scrollHeight;
  278.     }
  280.     function setTestStatus(testNumber, status, message) {
  281.         const statusElement = document.getElementById(`test${testNumber}-status`);
  282.         const testCard = document.getElementById(`test${testNumber}`);
  284.         testCard.classList.remove('running', 'success', 'error');
  286.         const statusMapping = {
  287.             running: { className: 'badge badge-warning', text: 'En cours...' },
  288.             success: { className: 'badge badge-success', text: 'Réussi' },
  289.             error:   { className: 'badge badge-danger',  text: 'Échec' },
  290.             waiting: { className: 'badge badge-secondary', text: 'En attente' }
  291.         };
  293.         const statusConfig = statusMapping[status];
  294.         if (statusConfig) {
  295.             statusElement.className = statusConfig.className;
  296.             statusElement.textContent = statusConfig.text;
  297.             if (status !== 'waiting') testCard.classList.add(status);
  298.         }
  300.         if (message) {
  301.             logToTest(testNumber, status === 'error' ? 'error' : 'info', message);
  302.         }
  303.     }
  305.     function resetAllTestStatuses() {
  306.         for (let testIndex = 1; testIndex <= TOTAL_TESTS; testIndex++) {
  307.             setTestStatus(testIndex, 'waiting');
  308.             const logElement = document.getElementById(`test${testIndex}-log`);
  309.             if (logElement) logElement.innerHTML = '';
  310.         }
  311.         const summaryElement = document.getElementById('globalSummary');
  312.         summaryElement.classList.remove('visible', 'alert-success', 'alert-danger', 'alert-warning');
  313.     }
  315.     function deleteCookies() {
  316.         const domain = window.location.hostname.split('.').slice(-2).join('.');
  318.         COOKIES_TO_DELETE.forEach(cookieName => {
  319.             document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; domain=${domain}`;
  320.             document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; domain=.${domain}`;
  321.             document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
  322.         });
  323.     }
  325.     function getCookieValue(cookieName) {
  326.         const cookieArray = document.cookie.split(";");
  327.         for (let index = 0; index < cookieArray.length; index++) {
  328.             const cookiePair = cookieArray[index].split("=");
  329.             if (cookieName === cookiePair[0].trim()) {
  330.                 return decodeURIComponent(cookiePair[1]);
  331.             }
  332.         }
  333.         return null;
  334.     }
  336.     async function deleteFingerprints(testNumber) {
  337.         if (getSelectedEnvironment() === 'prod') {
  338.             logToTest(testNumber, 'info', 'Environnement prod: suppression des fingerprints non disponible, étape ignorée');
  339.             return;
  340.         }
  342.         logToTest(testNumber, 'info', 'Suppression des fingerprints dans la matrice...');
  344.         const browserSignature = [
  345.             navigator?.userAgent ?? '',
  346.             navigator?.language ?? '',
  347.             screen?.width ?? 0,
  348.             screen?.height ?? 0,
  349.             navigator?.deviceMemory ?? 0,
  350.             navigator?.hardwareConcurrency ?? 0
  351.         ].join("::");
  353.         const queryParams = new URLSearchParams({ bs: browserSignature });
  354.         const deleteUrlV4 = DELETE_FG_PREPROD_V4 + '?' + queryParams.toString();
  355.         const deleteUrlV6 = DELETE_FG_PREPROD_V6 + '?' + queryParams.toString();
  357.         const [responseV4, responseV6] = await Promise.allSettled([
  358.             fetch(deleteUrlV4, { method: 'DELETE', credentials: 'include' }),
  359.             fetch(deleteUrlV6, { method: 'DELETE', credentials: 'include' })
  360.         ]);
  362.         const isV4Ok = responseV4.status === 'fulfilled' && responseV4.value.ok;
  363.         const isV6Ok = responseV6.status === 'fulfilled' && responseV6.value.ok;
  365.         if (isV4Ok || isV6Ok) {
  366.             logToTest(testNumber, 'info', 'Fingerprints supprimés avec succès');
  367.         } else {
  368.             logToTest(testNumber, 'debug', 'Suppression des fingerprints échouée (non bloquant)');
  369.         }
  370.     }
  372.     function cleanSdkGlobals() {
  373.         delete window.FIRSTID;
  374.         delete window.FIRSTID_BY_TYPE;
  375.         delete window.FIRSTID_LOADING;
  376.         const existingScripts = document.querySelectorAll('script[src*="first-id.fr"]');
  377.         existingScripts.forEach(script => script.remove());
  378.     }
  380.     function configureSdkWindow(extraConfig = {}) {
  381.         window.firstId = {
  382.             callbacks: [],
  383.             debug: true,
  384.             cookieName: 'firstid',
  385.             firstIdFlexFeature: true,
  386.             cookieSyncEnabled: false,
  387.             ...extraConfig
  388.         };
  389.     }
  391.     function loadFirstIdScript(testNumber, scriptUrl) {
  392.         const loaderUrl = scriptUrl || getCdnLoaderFlexUrl();
  393.         return new Promise((resolve, reject) => {
  394.             if (document.querySelector('script[src*="first-id.fr"]')) {
  395.                 logToTest(testNumber, 'info', 'Script FirstID déjà chargé');
  396.                 resolve();
  397.                 return;
  398.             }
  400.             const script = document.createElement('script');
  401.             script.src = loaderUrl;
  402.             script.defer = true;
  403.             script.onload = () => {
  404.                 logToTest(testNumber, 'info', 'Script FirstID chargé avec succès');
  405.                 resolve();
  406.             };
  407.             script.onerror = () => reject(new Error('Échec du chargement du script First-ID'));
  408.             document.head.appendChild(script);
  409.         });
  410.     }
  412.     function waitForFirstIdInitialized(testNumber, timeoutMs = SDK_LOAD_TIMEOUT_MS) {
  413.         return new Promise((resolve, reject) => {
  414.             let settled = false;
  415.             const timeout = setTimeout(() => {
  416.                 if (settled) return;
  417.                 settled = true;
  418.                 document.removeEventListener('firstId:initialized', handler);
  419.                 reject(new Error(`Timeout FirstID après ${timeoutMs}ms`));
  420.             }, timeoutMs);
  422.             function handler(event) {
  423.                 if (settled) return;
  424.                 settled = true;
  425.                 clearTimeout(timeout);
  426.                 document.removeEventListener('firstId:initialized', handler);
  427.                 const firstId = event.detail?.firstId || event.detail;
  428.                 logToTest(testNumber, 'info', `FirstID initialisé: ${firstId}`);
  429.                 resolve(firstId);
  430.             }
  432.             document.addEventListener('firstId:initialized', handler);
  433.         });
  434.     }
  436.     async function ensureSdkLoaded(testNumber, extraConfig = {}) {
  437.         if (window.FIRSTID && window.FIRSTID.getId && window.FIRSTID.getId()) {
  438.             logToTest(testNumber, 'info', 'SDK déjà chargé, réutilisation');
  439.             return window.FIRSTID.getId();
  440.         }
  442.         cleanSdkGlobals();
  443.         configureSdkWindow(extraConfig);
  444.         await loadFirstIdScript(testNumber);
  445.         logToTest(testNumber, 'info', 'Attente de l\'initialisation du SDK...');
  446.         const firstId = await waitForFirstIdInitialized(testNumber);
  447.         await new Promise(resolve => setTimeout(resolve, 500));
  448.         return firstId;
  449.     }
  451.     function listenForIframeMessage(expectedType, testNumber, timeoutMs = IFRAME_TIMEOUT_MS) {
  452.         return new Promise((resolve, reject) => {
  453.             let settled = false;
  455.             const timeout = setTimeout(() => {
  456.                 if (settled) return;
  457.                 settled = true;
  458.                 window.removeEventListener('message', handler);
  459.                 reject(new Error(`Timeout iframe après ${timeoutMs / 1000} secondes`));
  460.             }, timeoutMs);
  462.             function handler(event) {
  463.                 if (!event.data || !event.data.type) return;
  465.                 if (event.data.type === 'iframeLog') {
  466.                     logToTest(testNumber, 'debug', `[IFRAME] ${event.data.message}`);
  467.                     return;
  468.                 }
  470.                 if (event.data.type === expectedType) {
  471.                     if (settled) return;
  472.                     settled = true;
  473.                     clearTimeout(timeout);
  474.                     window.removeEventListener('message', handler);
  475.                     resolve(event.data);
  476.                     return;
  477.                 }
  479.                 if (event.data.type === 'scriptError' || event.data.type === 'gateError') {
  480.                     if (settled) return;
  481.                     settled = true;
  482.                     clearTimeout(timeout);
  483.                     window.removeEventListener('message', handler);
  484.                     reject(new Error(event.data.error || 'Erreur dans l\'iframe'));
  485.                 }
  486.             }
  488.             window.addEventListener('message', handler);
  489.         });
  490.     }
  492.     function showGlobalSummary() {
  493.         const summaryElement = document.getElementById('globalSummary');
  494.         const passedTests = Object.values(testState.results).filter(result => result === true).length;
  495.         const failedTests = Object.values(testState.results).filter(result => result === false).length;
  496.         const totalExecuted = passedTests + failedTests;
  497.         const durationMs = Date.now() - testState.suiteStartTime;
  498.         const durationSeconds = (durationMs / 1000).toFixed(1);
  500.         document.getElementById('summaryTitle').textContent =
  501.             passedTests === totalExecuted ? 'Tous les tests sont passés' : `${failedTests} test(s) échoué(s)`;
  502.         document.getElementById('summaryDetails').textContent =
  503.             `${passedTests}/${totalExecuted} tests réussis`;
  504.         document.getElementById('summaryDuration').textContent =
  505.             `Durée totale: ${durationSeconds}s`;
  507.         summaryElement.classList.remove('alert-success', 'alert-danger', 'alert-warning');
  508.         if (failedTests === 0) {
  509.             summaryElement.classList.add('alert-success');
  510.         } else if (passedTests === 0) {
  511.             summaryElement.classList.add('alert-danger');
  512.         } else {
  513.             summaryElement.classList.add('alert-warning');
  514.         }
  515.         summaryElement.classList.add('visible');
  516.     }
  518.     async function runTest1() {
  519.         const testNumber = 1;
  520.         setTestStatus(testNumber, 'running', 'Démarrage du Test 1...');
  521.         setupConsoleInterceptor(testNumber);
  523.         try {
  524.             logToTest(testNumber, 'info', 'Suppression des cookies...');
  525.             deleteCookies();
  526.             logToTest(testNumber, 'info', 'Cookies supprimés');
  528.             logToTest(testNumber, 'info', 'Réinitialisation de la matrice (fingerprints)...');
  529.             await deleteFingerprints(testNumber);
  531.             logToTest(testNumber, 'info', 'Chargement du script FirstID...');
  532.             cleanSdkGlobals();
  533.             configureSdkWindow();
  534.             await loadFirstIdScript(testNumber);
  536.             logToTest(testNumber, 'info', 'Initialisation du SDK...');
  537.             const firstId = await waitForFirstIdInitialized(testNumber);
  539.             if (!firstId) throw new Error('FirstID non obtenu après initialisation');
  540.             if (interceptedErrors.length > 0) {
  541.                 throw new Error(`${interceptedErrors.length} erreur(s) console détectée(s)`);
  542.             }
  544.             logToTest(testNumber, 'info', `✓ FirstID obtenu: ${firstId}`);
  545.             logToTest(testNumber, 'info', '✓ Aucune erreur console détectée');
  546.             setTestStatus(testNumber, 'success', 'Test 1 réussi');
  547.             testState.results[testNumber] = true;
  548.         } catch (error) {
  549.             setTestStatus(testNumber, 'error', `Test 1 échoué: ${error.message}`);
  550.             testState.results[testNumber] = false;
  551.         } finally {
  552.             teardownConsoleInterceptor();
  553.         }
  554.     }
  556.     async function runTest2() {
  557.         const testNumber = 2;
  558.         setTestStatus(testNumber, 'running', 'Démarrage du Test 2...');
  559.         setupConsoleInterceptor(testNumber);
  561.         try {
  562.             logToTest(testNumber, 'info', 'Rechargement du SDK sans suppression des cookies...');
  563.             cleanSdkGlobals();
  564.             configureSdkWindow();
  565.             logToTest(testNumber, 'info', 'Variables globales réinitialisées');
  567.             await loadFirstIdScript(testNumber);
  569.             logToTest(testNumber, 'info', 'Initialisation du SDK...');
  570.             const firstId = await waitForFirstIdInitialized(testNumber);
  572.             if (!firstId) throw new Error('FirstID non obtenu après réinitialisation');
  573.             if (interceptedErrors.length > 0) {
  574.                 throw new Error(`${interceptedErrors.length} erreur(s) console détectée(s)`);
  575.             }
  577.             logToTest(testNumber, 'info', `✓ FirstID obtenu: ${firstId}`);
  578.             logToTest(testNumber, 'info', '✓ Aucune erreur console détectée');
  579.             setTestStatus(testNumber, 'success', 'Test 2 réussi');
  580.             testState.results[testNumber] = true;
  581.         } catch (error) {
  582.             setTestStatus(testNumber, 'error', `Test 2 échoué: ${error.message}`);
  583.             testState.results[testNumber] = false;
  584.         } finally {
  585.             teardownConsoleInterceptor();
  586.         }
  587.     }
  589.     async function callMaidMatchingApi(payload) {
  590.         const response = await fetch(MAID_MATCHING_API_PROXY_URL, {
  591.             method: 'POST',
  592.             headers: { 'Content-Type': 'application/json' },
  593.             body: JSON.stringify(payload)
  594.         });
  596.         if (!response.ok) {
  597.             const errorText = await response.text();
  598.             throw new Error(`API call failed: ${response.status} - ${errorText}`);
  599.         }
  601.         return await response.json();
  602.     }
  604.     function generateMobileDeviceData(variant) {
  605.         const devices = [
  606.             {
  607.                 deviceType: 'mobile_test_suite', deviceManufacturer: 'Apple',
  608.                 deviceModel: 'iPhone 14 Pro', osVersion: '17.2', buildId: '21C5050',
  609.                 deviceRam: 6000, deviceResolution: '1179x2556', appIdentifier: 'com.firstid.testapp'
  610.             },
  611.             {
  612.                 deviceType: 'mobile_test_suite', deviceManufacturer: 'Samsung',
  613.                 deviceModel: 'Galaxy S23', osVersion: '14', buildId: 'TP1A.220624.014',
  614.                 deviceRam: 8000, deviceResolution: '1080x2340', appIdentifier: 'com.firstid.testapp'
  615.             },
  616.             {
  617.                 deviceType: 'mobile_test_suite', deviceManufacturer: 'Google',
  618.                 deviceModel: 'Pixel 8', osVersion: '14', buildId: 'UP1A.231105.003',
  619.                 deviceRam: 8000, deviceResolution: '1080x2400', appIdentifier: 'com.firstid.testapp'
  620.             }
  621.         ];
  622.         const selectedDevice = devices[variant - 1] || devices[0];
  623.         return { ...selectedDevice, dfid: "true" };
  624.     }
  626.     async function runTest3() {
  627.         const testNumber = 3;
  628.         setTestStatus(testNumber, 'running', 'Démarrage du Test 3...');
  630.         try {
  631.             logToTest(testNumber, 'info', '=== Test 3: Appels APP API Mobile ===');
  633.             logToTest(testNumber, 'info', '--- Appel 1: Création initiale (sans firstId) ---');
  634.             const deviceData1 = generateMobileDeviceData(1);
  635.             const payload1 = { ...deviceData1, maid: crypto.randomUUID() };
  636.             logToTest(testNumber, 'info', `Device: ${deviceData1.deviceManufacturer} ${deviceData1.deviceModel}`);
  638.             const response1 = await callMaidMatchingApi(payload1);
  639.             if (!response1.firstId) throw new Error('Premier appel: firstId non reçu');
  640.             const obtainedFirstId = response1.firstId;
  641.             logToTest(testNumber, 'info', `✓ FirstID obtenu: ${obtainedFirstId}`);
  643.             await new Promise(resolve => setTimeout(resolve, 500));
  645.             logToTest(testNumber, 'info', '--- Appel 2: Avec firstId + données device différentes ---');
  646.             const deviceData2 = generateMobileDeviceData(2);
  647.             const payload2 = { ...deviceData2, firstId: obtainedFirstId, maid: crypto.randomUUID() };
  649.             const response2 = await callMaidMatchingApi(payload2);
  650.             if (!response2.firstId) throw new Error('Deuxième appel: firstId non reçu');
  651.             if (response2.firstId !== obtainedFirstId) {
  652.                 throw new Error('Le firstId retourné est différent de celui envoyé');
  653.             }
  654.             logToTest(testNumber, 'info', '✓ FirstID identique confirmé');
  656.             await new Promise(resolve => setTimeout(resolve, 500));
  658.             logToTest(testNumber, 'info', '--- Appel 3: Sans firstId avec mêmes données que appel 2 ---');
  659.             const payload3 = { ...deviceData2, maid: payload2.maid };
  661.             const response3 = await callMaidMatchingApi(payload3);
  662.             if (!response3.firstId) throw new Error('Troisième appel: firstId non reçu');
  663.             if (response3.firstId !== obtainedFirstId) {
  664.                 throw new Error('Le firstId retrouvé ne correspond pas au firstId initial');
  665.             }
  666.             logToTest(testNumber, 'info', '✓ FirstID retrouvé avec succès via MAID');
  668.             logToTest(testNumber, 'info', '=== Résumé: Tous les appels ont retourné le même firstId ===');
  669.             setTestStatus(testNumber, 'success', 'Test 3 réussi - API Mobile validée');
  670.             testState.results[testNumber] = true;
  671.         } catch (error) {
  672.             logToTest(testNumber, 'error', `Erreur détaillée: ${error.message}`);
  673.             setTestStatus(testNumber, 'error', `Test 3 échoué: ${error.message}`);
  674.             testState.results[testNumber] = false;
  675.         }
  676.     }
  678.     async function runTest4() {
  679.         const testNumber = 4;
  680.         setTestStatus(testNumber, 'running', 'Démarrage du Test 4...');
  682.         try {
  683.             logToTest(testNumber, 'info', 'Test de la redirection Gate via page dédiée...');
  685.             const iframeContainer = document.getElementById('test4-iframe-container');
  686.             iframeContainer.innerHTML = '';
  688.             const iframe = document.createElement('iframe');
  689.             const environment = getSelectedEnvironment();
  690.             iframe.src = `/test-suite/iframe/gate?env=${environment}`;
  691.             logToTest(testNumber, 'info', `URL iframe Gate: ${iframe.src}`);
  693.             iframeContainer.appendChild(iframe);
  695.             const messagePromise = listenForIframeMessage('gateFirstIdReceived', testNumber);
  696.             const messageData = await messagePromise;
  698.             const receivedFirstId = messageData.firstId;
  699.             logToTest(testNumber, 'info', `✓ FirstID reçu de la Gate: ${receivedFirstId}`);
  701.             await new Promise(resolve => setTimeout(resolve, 1000));
  703.             const firstIdCookie = getCookieValue('firstid');
  704.             if (firstIdCookie) {
  705.                 logToTest(testNumber, 'info', `✓ Cookie firstid trouvé: ${firstIdCookie}`);
  706.             } else {
  707.                 logToTest(testNumber, 'info', 'Cookie firstid non trouvé sur le domaine parent (attendu en cross-domain)');
  708.             }
  710.             setTestStatus(testNumber, 'success', 'Test 4 réussi');
  711.             testState.results[testNumber] = true;
  712.         } catch (error) {
  713.             setTestStatus(testNumber, 'error', `Test 4 échoué: ${error.message}`);
  714.             testState.results[testNumber] = false;
  715.         }
  716.     }
  718.     async function runTest5() {
  719.         const testNumber = 5;
  720.         setTestStatus(testNumber, 'running', 'Démarrage du Test 5...');
  722.         try {
  723.             logToTest(testNumber, 'info', '=== Test 5: SDK Premium Lite dans iframe dédiée ===');
  725.             const iframeContainer = document.getElementById('test5-iframe-container');
  726.             iframeContainer.innerHTML = '';
  728.             const iframe = document.createElement('iframe');
  729.             iframe.id = 'test5-iframe';
  730.             const environment = getSelectedEnvironment();
  731.             iframe.src = `/test-suite/iframe/premium-lite?env=${environment}`;
  732.             logToTest(testNumber, 'info', `URL iframe Premium Lite: ${iframe.src}`);
  734.             iframeContainer.appendChild(iframe);
  736.             const messageData = await listenForIframeMessage('firstIdInitialized', testNumber);
  737.             const iframeFirstId = messageData.firstId;
  738.             logToTest(testNumber, 'info', `✓ FirstID obtenu via SDK dans iframe: ${iframeFirstId}`);
  740.             await new Promise(resolve => setTimeout(resolve, 2000));
  742.             const firstIdCookie = getCookieValue('firstid');
  743.             if (firstIdCookie) {
  744.                 logToTest(testNumber, 'info', `✓ Cookie firstid vérifié: ${firstIdCookie}`);
  745.                 if (firstIdCookie === iframeFirstId) {
  746.                     logToTest(testNumber, 'info', '✓ FirstID du SDK correspond au cookie');
  747.                 } else {
  748.                     logToTest(testNumber, 'info', `FirstID SDK=${iframeFirstId}, Cookie=${firstIdCookie} (peut différer en cross-domain)`);
  749.                 }
  750.             } else {
  751.                 logToTest(testNumber, 'info', 'Cookie firstid non trouvé sur le domaine parent (attendu en cross-domain)');
  752.             }
  754.             setTestStatus(testNumber, 'success', 'Test 5 réussi');
  755.             testState.results[testNumber] = true;
  756.         } catch (error) {
  757.             setTestStatus(testNumber, 'error', `Test 5 échoué: ${error.message}`);
  758.             testState.results[testNumber] = false;
  759.         }
  760.     }
  762.     async function runTest6() {
  763.         const testNumber = 6;
  764.         setTestStatus(testNumber, 'running', 'Démarrage du Test 6...');
  765.         setupConsoleInterceptor(testNumber);
  767.         const TEST_EMAIL_HASH = 'e473c325a4d7cd827f532e93b1f61932b8acba5595c172f47c3cf498ac45d913';
  769.         try {
  770.             logToTest(testNumber, 'info', '=== Test 6: Ajout d\'un email hashé ===');
  771.             logToTest(testNumber, 'info', `Email hashé à tester: ${TEST_EMAIL_HASH}`);
  773.             await ensureSdkLoaded(testNumber);
  775.             if (!window.FIRSTID) throw new Error('SDK FirstID non disponible après chargement');
  776.             if (!window.FIRSTID.setEmailHashed) {
  777.                 throw new Error('La méthode setEmailHashed n\'est pas disponible dans ce SDK');
  778.             }
  780.             const firstIdBefore = window.FIRSTID.getId ? window.FIRSTID.getId() : null;
  781.             logToTest(testNumber, 'info', `FirstID avant ajout email: ${firstIdBefore || 'non disponible'}`);
  783.             await window.FIRSTID.setEmailHashed(TEST_EMAIL_HASH);
  784.             logToTest(testNumber, 'info', '✓ setEmailHashed appelé avec succès');
  786.             await new Promise(resolve => setTimeout(resolve, 2000));
  788.             const emailHashCookie = getCookieValue('fid_email_hashed');
  789.             if (emailHashCookie) {
  790.                 logToTest(testNumber, 'info', `✓ Cookie fid_email_hashed trouvé: ${emailHashCookie}`);
  791.             } else {
  792.                 logToTest(testNumber, 'info', 'Cookie fid_email_hashed non trouvé (peut être normal selon l\'implémentation)');
  793.             }
  795.             logToTest(testNumber, 'info', '✓ Email hashé ajouté avec succès');
  796.             setTestStatus(testNumber, 'success', 'Test 6 réussi - Email hashé ajouté');
  797.             testState.results[testNumber] = true;
  798.         } catch (error) {
  799.             logToTest(testNumber, 'error', `Erreur détaillée: ${error.message}`);
  800.             setTestStatus(testNumber, 'error', `Test 6 échoué: ${error.message}`);
  801.             testState.results[testNumber] = false;
  802.         } finally {
  803.             teardownConsoleInterceptor();
  804.         }
  805.     }
  807.     async function runTest7() {
  808.         const testNumber = 7;
  809.         setTestStatus(testNumber, 'running', 'Démarrage du Test 7...');
  810.         setupConsoleInterceptor(testNumber);
  812.         const timestamp = Date.now();
  813.         const CXENSE_ID = `TestSuite_${timestamp}`;
  815.         try {
  816.             logToTest(testNumber, 'info', '=== Test 7: setCustomData avec cxenseid ===');
  817.             logToTest(testNumber, 'info', `cxenseid à tester: ${CXENSE_ID}`);
  819.             await ensureSdkLoaded(testNumber);
  821.             if (!window.FIRSTID) throw new Error('SDK FirstID non disponible après chargement');
  822.             if (!window.FIRSTID.setCustomData) {
  823.                 throw new Error('La méthode setCustomData n\'est pas disponible dans ce SDK');
  824.             }
  826.             const firstIdInitial = window.FIRSTID.getId ? window.FIRSTID.getId() : null;
  827.             if (!firstIdInitial) throw new Error('Aucun firstId disponible avant setCustomData');
  828.             logToTest(testNumber, 'info', `FirstID initial: ${firstIdInitial}`);
  830.             await window.FIRSTID.setCustomData({ cxenseid: CXENSE_ID });
  831.             logToTest(testNumber, 'info', '✓ setCustomData appelé avec succès');
  832.             await new Promise(resolve => setTimeout(resolve, 2000));
  834.             logToTest(testNumber, 'info', 'Suppression de tous les cookies...');
  835.             deleteCookies();
  837.             logToTest(testNumber, 'info', 'Réinitialisation de la matrice (fingerprints)...');
  838.             await deleteFingerprints(testNumber);
  840.             logToTest(testNumber, 'info', 'Réinitialisation et rechargement du SDK...');
  841.             cleanSdkGlobals();
  842.             configureSdkWindow({ customData: { cxenseid: CXENSE_ID } });
  844.             await loadFirstIdScript(testNumber);
  845.             logToTest(testNumber, 'info', 'Attente de l\'initialisation du SDK...');
  846.             await waitForFirstIdInitialized(testNumber);
  848.             if (!window.FIRSTID) throw new Error('SDK FirstID non disponible après rechargement');
  850.             const firstIdRecovered = window.FIRSTID.getId ? window.FIRSTID.getId() : null;
  851.             if (!firstIdRecovered) throw new Error('Aucun firstId récupéré après rechargement avec customData');
  853.             logToTest(testNumber, 'info', `FirstID récupéré: ${firstIdRecovered}`);
  855.             if (firstIdRecovered !== firstIdInitial) {
  856.                 throw new Error('Le firstId récupéré ne correspond pas au firstId initial');
  857.             }
  859.             logToTest(testNumber, 'info', '✓ FirstID identique confirmé');
  860.             logToTest(testNumber, 'info', '✓ Le customData a permis de récupérer le même firstId');
  861.             setTestStatus(testNumber, 'success', 'Test 7 réussi - setCustomData validé');
  862.             testState.results[testNumber] = true;
  863.         } catch (error) {
  864.             logToTest(testNumber, 'error', `Erreur détaillée: ${error.message}`);
  865.             setTestStatus(testNumber, 'error', `Test 7 échoué: ${error.message}`);
  866.             testState.results[testNumber] = false;
  867.         } finally {
  868.             teardownConsoleInterceptor();
  869.         }
  870.     }
  872.     async function runTest8() {
  873.         const testNumber = 8;
  874.         setTestStatus(testNumber, 'running', 'Démarrage du Test 8...');
  875.         setupConsoleInterceptor(testNumber);
  877.         try {
  878.             logToTest(testNumber, 'info', '=== Test 8: getDeviceId et getFirstIdEidsObject ===');
  880.             await ensureSdkLoaded(testNumber);
  882.             if (!window.FIRSTID) throw new Error('SDK FirstID non disponible après chargement');
  884.             const firstId = window.FIRSTID.getId ? window.FIRSTID.getId() : null;
  885.             if (!firstId) throw new Error('Aucun firstId disponible');
  886.             logToTest(testNumber, 'info', `FirstID disponible: ${firstId}`);
  888.             logToTest(testNumber, 'info', '--- Test getDeviceId ---');
  889.             if (!window.FIRSTID.getDeviceId) {
  890.                 throw new Error('La méthode getDeviceId n\'est pas disponible dans ce SDK');
  891.             }
  893.             const deviceId = await window.FIRSTID.getDeviceId();
  894.             if (!deviceId) throw new Error('getDeviceId a retourné null ou undefined');
  895.             logToTest(testNumber, 'info', `✓ DeviceId obtenu: ${deviceId}`);
  897.             const deviceIdSecondCall = await window.FIRSTID.getDeviceId();
  898.             if (deviceIdSecondCall !== deviceId) {
  899.                 throw new Error('Le deviceId n\'est pas stable entre les appels');
  900.             }
  901.             logToTest(testNumber, 'info', '✓ DeviceId identique confirmé');
  903.             logToTest(testNumber, 'info', '--- Test getFirstIdEidsObject ---');
  904.             if (!window.FIRSTID.getFirstIdEidsObject) {
  905.                 throw new Error('La méthode getFirstIdEidsObject n\'est pas disponible dans ce SDK');
  906.             }
  908.             const eidsObject = window.FIRSTID.getFirstIdEidsObject();
  909.             if (!eidsObject || !Array.isArray(eidsObject) || eidsObject.length === 0) {
  910.                 throw new Error('getFirstIdEidsObject n\'a pas retourné un tableau valide');
  911.             }
  913.             const eidsEntry = eidsObject[0];
  914.             if (!eidsEntry.source || eidsEntry.source !== 'first-id.fr') {
  915.                 throw new Error(`Source incorrecte: ${eidsEntry.source}, attendu: first-id.fr`);
  916.             }
  917.             if (!eidsEntry.uids || !Array.isArray(eidsEntry.uids) || eidsEntry.uids.length === 0) {
  918.                 throw new Error('uids manquant ou invalide');
  919.             }
  921.             const uidEntry = eidsEntry.uids[0];
  922.             if (uidEntry.atype !== 1) throw new Error(`atype incorrect: ${uidEntry.atype}, attendu: 1`);
  923.             if (!uidEntry.ext || uidEntry.ext.stype !== 'ppuid') {
  924.                 throw new Error(`ext.stype incorrect: ${uidEntry.ext?.stype}, attendu: ppuid`);
  925.             }
  926.             if (uidEntry.id !== firstId) {
  927.                 throw new Error(`id incorrect: ${uidEntry.id}, attendu: ${firstId}`);
  928.             }
  930.             logToTest(testNumber, 'info', '✓ Structure eidsObject valide');
  931.             logToTest(testNumber, 'info', `  - source: ${eidsEntry.source}, atype: ${uidEntry.atype}, ext.stype: ${uidEntry.ext.stype}`);
  933.             setTestStatus(testNumber, 'success', 'Test 8 réussi - getDeviceId et getFirstIdEidsObject validés');
  934.             testState.results[testNumber] = true;
  935.         } catch (error) {
  936.             logToTest(testNumber, 'error', `Erreur détaillée: ${error.message}`);
  937.             setTestStatus(testNumber, 'error', `Test 8 échoué: ${error.message}`);
  938.             testState.results[testNumber] = false;
  939.         } finally {
  940.             teardownConsoleInterceptor();
  941.         }
  942.     }
  944.     async function runTest9() {
  945.         const testNumber = 9;
  946.         setTestStatus(testNumber, 'running', 'Démarrage du Test 9...');
  947.         setupConsoleInterceptor(testNumber);
  949.         const EXPECTED_MASTER_TYPE = 1;
  950.         const SLAVE_FIRST_ID = 'c8f6459136c6469ca43d3838082b94eb';
  952.         try {
  953.             logToTest(testNumber, 'info', '=== Test 9: getMasterFirstId ===');
  955.             deleteCookies();
  957.             logToTest(testNumber, 'info', 'Réinitialisation de la matrice (fingerprints)...');
  958.             await deleteFingerprints(testNumber);
  960.             cleanSdkGlobals();
  961.             configureSdkWindow();
  963.             const domain = window.location.hostname.split('.').slice(-2).join('.');
  964.             document.cookie = `firstid=${SLAVE_FIRST_ID}; path=/; domain=${domain}`;
  965.             logToTest(testNumber, 'info', `Cookie firstid défini avec le slave: ${SLAVE_FIRST_ID}`);
  967.             await loadFirstIdScript(testNumber);
  968.             logToTest(testNumber, 'info', 'Attente de l\'initialisation du SDK...');
  969.             await waitForFirstIdInitialized(testNumber);
  971.             if (!window.FIRSTID) throw new Error('SDK FirstID non disponible après chargement');
  972.             if (!window.FIRSTID.getMasterFirstId) {
  973.                 throw new Error('La méthode getMasterFirstId n\'est pas disponible dans ce SDK');
  974.             }
  976.             const masterFirstId = window.FIRSTID.getId ? window.FIRSTID.getId() : null;
  977.             if (!masterFirstId) throw new Error('Aucun firstId disponible');
  979.             if (masterFirstId !== SLAVE_FIRST_ID) {
  980.                 logToTest(testNumber, 'info', `FirstID actuel (${masterFirstId}) différent du slave (${SLAVE_FIRST_ID})`);
  981.             } else {
  982.                 logToTest(testNumber, 'info', `Master FirstID confirmé: ${masterFirstId}`);
  983.             }
  985.             const firstIdTypeAfter = window.FIRSTID.getIdStruct
  986.                 ? (window.FIRSTID.getIdStruct().t || null)
  987.                 : null;
  989.             if (firstIdTypeAfter !== EXPECTED_MASTER_TYPE) {
  990.                 throw new Error(`Le type du firstId ne correspond pas. Attendu: ${EXPECTED_MASTER_TYPE}, Reçu: ${firstIdTypeAfter}`);
  991.             }
  992.             logToTest(testNumber, 'info', `✓ Type correct: ${firstIdTypeAfter}`);
  994.             if (masterFirstId === SLAVE_FIRST_ID) {
  995.                 throw new Error('Le master firstId est identique au slave firstId');
  996.             }
  997.             logToTest(testNumber, 'info', '✓ Master FirstID différent du slave confirmé');
  999.             const cookieAfter = getCookieValue('firstid');
  1000.             if (cookieAfter && cookieAfter === masterFirstId) {
  1001.                 logToTest(testNumber, 'info', `✓ Cookie firstid mis à jour avec le master: ${cookieAfter}`);
  1002.             }
  1004.             logToTest(testNumber, 'info', '=== Résumé du Test 9 ===');
  1005.             logToTest(testNumber, 'info', `✓ Slave: ${SLAVE_FIRST_ID} → Master: ${masterFirstId} (type: ${firstIdTypeAfter})`);
  1007.             setTestStatus(testNumber, 'success', 'Test 9 réussi - getMasterFirstId validé');
  1008.             testState.results[testNumber] = true;
  1009.         } catch (error) {
  1010.             logToTest(testNumber, 'error', `Erreur détaillée: ${error.message}`);
  1011.             setTestStatus(testNumber, 'error', `Test 9 échoué: ${error.message}`);
  1012.             testState.results[testNumber] = false;
  1013.         } finally {
  1014.             teardownConsoleInterceptor();
  1015.         }
  1016.     }
  1018.     function waitForConsent() {
  1019.         return new Promise((resolve) => {
  1020.             if (!window.__tcfapi) {
  1021.                 logToTest(1, 'info', 'TCF API non disponible, passage en mode sans consentement');
  1022.                 resolve(true);
  1023.                 return;
  1024.             }
  1026.             window.__tcfapi('addEventListener', 2, (tcData, success) => {
  1027.                 if (success && tcData.gdprApplies) {
  1028.                     if (tcData.vendor.consents[FIRSTID_VENDOR_ID] &&
  1029.                         (tcData.eventStatus === 'useractioncomplete' || tcData.eventStatus === 'tcloaded')) {
  1030.                         testState.hasConsent = true;
  1031.                         resolve(true);
  1032.                     }
  1033.                 } else {
  1034.                     resolve(true);
  1035.                 }
  1036.             });
  1037.         });
  1038.     }
  1040.     document.getElementById('startAllTests').addEventListener('click', async function () {
  1041.         this.disabled = true;
  1042.         resetTestState();
  1043.         resetAllTestStatuses();
  1044.         testState.suiteStartTime = Date.now();
  1046.         logToTest(1, 'info', 'Attente du consentement TCF...');
  1047.         await waitForConsent();
  1049.         await runTest1();
  1051.         if (testState.results[1]) {
  1052.             await runTest2();
  1053.         }
  1055.         await runTest3();
  1057.         await runTest4();
  1059.         await runTest5();
  1061.         if (testState.results[1] || testState.results[2]) {
  1062.             await runTest6();
  1063.         }
  1065.         if (testState.results[1] || testState.results[2]) {
  1066.             await runTest7();
  1067.         }
  1069.         if (testState.results[1] || testState.results[2]) {
  1070.             await runTest8();
  1071.         }
  1073.         if (testState.results[1] || testState.results[2]) {
  1074.             await runTest9();
  1075.         }
  1077.         showGlobalSummary();
  1078.         this.disabled = false;
  1079.     });
  1080. </script>
  1081. </body>
  1082. </html>