This is an automated email from the ASF dual-hosted git repository. sergehuber pushed a commit to branch UNOMI-1037-backport-1.x in repository https://gitbox.apache.org/repos/asf/unomi-tracker.git
commit 19a38c8f66f55f11a4450d42f55839def1ec9675 Author: Serge Huber <[email protected]> AuthorDate: Wed Nov 4 17:22:43 2026 +0100 UNOMI-1037, UNOMI-1038, UNOMI-1040 to UNOMI-1043, UNOMI-1046, UNOMI-1047: Backport the click and form tracking fixes to 1.x The fixes of #39 on main, for tracker 1.6.0: - UNOMI-1037: every click on a link or button is tracked, not only the first one, also a second click made before the first event is sent. - UNOMI-1040: links and forms work at once when Unomi cannot be reached or tracking is off, and wait 1.5s at most when there is no timeout. - UNOMI-1041: Ctrl or Cmd+click opens a new tab, and is still tracked. - UNOMI-1042: a tracked form is submitted with the button that was used. - UNOMI-1043: without a usable timeoutInMilliseconds, the default of 1500 ms is used, instead of every request failing at once. - UNOMI-1046: the site's own click handlers run once per click. - UNOMI-1047: a click inside a tracked link or button is tracked on it. - UNOMI-1038: sourceLocalIdentifierMap finds a mapped part anywhere in the id, also at its start. The browser tests of #39 come too, against Unomi 2.3, 2.7 and 3.0, in Chromium, Firefox and WebKit, and the Safari checks (yarn test:safari). Left out, as 1.x does not have them: Unomi 4, apiKey and sendCredentials tests, the CI workflow, and the README sections on 2.x. The test setup also waits until the server answers steadily before the tests, as on main: a starting Unomi 2.7 dropped its endpoints for a while. dist is not rebuilt, as in #29. Co-Authored-By: Claude Opus 5.5 <[email protected]> --- package.json | 1 + src/apache-unomi-tracker.js | 361 +++++++++++++++++++++++++---- test/servers/README.md | 61 +++++ test/servers/page/index.html | 208 ++++++++++++++++- test/servers/playwright.config.js | 21 +- test/servers/safari.js | 475 ++++++++++++++++++++++++++++++++++++++ test/servers/serve.js | 15 +- test/servers/tracker.spec.js | 437 ++++++++++++++++++++++++++++++++++- test/servers/unomi.js | 87 ++++++- test/spec.js | 253 +++++++++++++++++++- 10 files changed, 1844 insertions(+), 75 deletions(-) diff --git a/package.json b/package.json index 6eceb1f..6102a96 100644 --- a/package.json +++ b/package.json @@ -15,6 +15,7 @@ "build": "rollup -c", "test": "node test/spec", "test:servers": "node test/servers/run.js", + "test:safari": "node test/servers/safari.js", "pretest": "yarn run build", "lint": "eslint --ext js,json ." }, diff --git a/src/apache-unomi-tracker.js b/src/apache-unomi-tracker.js index f64abbf..173224d 100644 --- a/src/apache-unomi-tracker.js +++ b/src/apache-unomi-tracker.js @@ -17,6 +17,147 @@ import { Crawler } from 'es6-crawler-detect'; +/** + * Whether a link or form opening in the named browsing context replaces the current page: no name, + * or _self, _parent or _top. Another name opens another tab or window, and the page stays. + * @param {string | null} name the target or formtarget attribute + * @return {boolean} true if the current page is replaced + */ +function opensInThisPage(name) { + var context = (name || '').trim().toLowerCase(); + return context === '' || context === '_self' || context === '_parent' || context === '_top'; +} + +/** + * Whether a click on the element itself leaves the page: a link with an address that opens in + * this page (not in another tab or window, not a download, a #fragment or javascript:), or a + * button that submits its form into this page + * @param {Element} element an element + * @return {boolean} true if the click leaves the page + */ +function leavesPage(element) { + var tag = element.localName; + if (tag === 'a' || tag === 'area') { + var href = element.getAttribute('href'); + if (href === null) { + return false; + } + href = href.trim(); + if (href.charAt(0) === '#' || /^javascript:/i.test(href) || element.hasAttribute('download')) { + return false; + } + return opensInThisPage(element.getAttribute('target')); + } + var control = /** @type {HTMLButtonElement | HTMLInputElement} */(element); + var submits = (tag === 'button' && control.type === 'submit') || (tag === 'input' && (control.type === 'submit' || control.type === 'image')); + if (!submits || !control.form) { + return false; + } + return opensInThisPage(control.getAttribute('formtarget') || control.form.getAttribute('target')); +} + +/** + * The element whose click leaves the page, from the clicked element up: the clicked element can be + * inside a link or a button (an image, an icon, some text) + * @param {Element | null} element the clicked element + * @return {Element | null} the link or button, or null if the click stays on the page + */ +function elementLeavingPage(element) { + for (var node = element; node; node = node.parentElement) { + if (leavesPage(node)) { + return node; + } + } + return null; +} + +/** + * For an action held back while an event is sent: wraps its callbacks (event sent, not sent, no + * answer) so that only the first one called runs + * @return {function(function(XMLHttpRequest=): void): function(XMLHttpRequest=): void} wraps a callback so + * that only the first call runs + */ +function settleOnce() { + var settled = false; + return function (callback) { + return function (xhr) { + if (!settled) { + settled = true; + callback(xhr); + } + }; + }; +} + +/** + * Submits a form in browsers without requestSubmit: a copy of the submit event for the site's + * handlers, then submit(), with the submitting button's name and value added as a native submit does + * (for an image button, its click position, as 0,0), and the button's formaction, formmethod, + * formenctype and formtarget applied. + * @param {HTMLFormElement} form the form + * @param {HTMLButtonElement | HTMLInputElement | null} submitter the button that submitted it, if any + * @return {undefined} + */ +function submitWithoutRequestSubmit(form, submitter) { + /** @type {Event} */ + var eventCopy; + if (typeof SubmitEvent === 'function') { + eventCopy = new SubmitEvent('submit', { bubbles: true, cancelable: true, submitter: submitter }); + } else { + eventCopy = document.createEvent('Event'); + eventCopy.initEvent('submit', true, true); + } + form.dispatchEvent(eventCopy); + if (eventCopy.defaultPrevented) { + return; + } + /** @type {HTMLInputElement[]} */ + var fields = []; + if (submitter && submitter.name) { + var values = submitter.type === 'image' + ? [[submitter.name + '.x', '0'], [submitter.name + '.y', '0']] + : [[submitter.name, submitter.value]]; + values.forEach(function (nameAndValue) { + var field = document.createElement('input'); + field.type = 'hidden'; + field.name = nameAndValue[0]; + field.value = nameAndValue[1]; + form.appendChild(field); + fields.push(field); + }); + } + // The button's own address, method, encoding and target, as a native submit uses them + /** @type {Array<[string, string | null]>} */ + var formAttributes = []; + if (submitter) { + [['formaction', 'action'], ['formmethod', 'method'], ['formenctype', 'enctype'], ['formtarget', 'target']].forEach(function (names) { + var value = submitter.getAttribute(names[0]); + if (value !== null) { + formAttributes.push([names[1], form.getAttribute(names[1])]); + form.setAttribute(names[1], value); + } + }); + } + try { + // The data is read when submit() is called + HTMLFormElement.prototype.submit.call(form); + } finally { + fields.forEach(function (field) { + form.removeChild(field); + }); + formAttributes.forEach(function (nameAndValue) { + if (nameAndValue[1] === null) { + form.removeAttribute(nameAndValue[0]); + } else { + form.setAttribute(nameAndValue[0], nameAndValue[1]); + } + }); + } +} + +// Request timeout when the configuration gives none +const DEFAULT_TIMEOUT_IN_MILLISECONDS = 1500; + export const newTracker = () => { const wem = { /** @@ -36,7 +177,11 @@ export const newTracker = () => { const { contextServerUrl, timeoutInMilliseconds, contextServerCookieName } = wem.digitalData.wemInitConfig; wem.contextServerCookieName = contextServerCookieName; wem.contextServerUrl = contextServerUrl; - wem.timeoutInMilliseconds = timeoutInMilliseconds; + // A positive number of milliseconds, or -1 for none, also given as a string (as read from + // an HTML attribute). Anything else (missing, 0, another negative number, a blank string) + // would make the request timer fire at once and every request fail, so use the default. + var timeout = Number(/** @type {unknown} */(timeoutInMilliseconds)); + wem.timeoutInMilliseconds = isFinite(timeout) && (timeout === -1 || timeout > 0) ? timeout : DEFAULT_TIMEOUT_IN_MILLISECONDS; wem.formNamesToWatch = []; wem.eventsPrevented = []; wem.sessionID = wem.getCookie(wem.trackerSessionIdCookieName); @@ -397,44 +542,114 @@ export const newTracker = () => { /** * This function will build an event of type click and send it to Apache Unomi * + * The event is on the element the listener is on (event.currentTarget), or on the clicked + * element when that one has no id or name (as when called from a listener on the document). + * A click that leaves the page (on a link, or on a button that submits its form, also on an + * element inside them) is held back until the event is sent, or could not be, then + * dispatched again, so that the page does not close first; without a request timeout, it is + * held back for 1.5s at most. A click on a link that opens another tab or window, downloads, + * or stays on the page (#fragment, javascript:), a click the site already prevented, and any + * other click are not held back. A click with a modifier key (new tab or window, download) + * is not held back either, unless a callback is given. With a callback, a held back click is + * not dispatched again: the site handles it in the callback. When tracking is off, or Unomi + * could not be reached, the click is left alone and nothing is sent. + * * @param {object} event javascript * @param {function} [successCallback] optional, will be executed if case of success * @param {function} [errorCallback] optional, will be executed if case of error * @return {undefined} */ sendClickEvent: function (event, successCallback = undefined, errorCallback = undefined) { - if (event.target.id || event.target.name) { + // The element the listener is on, if it has an id or a name: the visitor may have clicked + // an image, an icon or some text inside it + var listening = /** @type {HTMLElement & { name: string } | null} */(event.currentTarget); + var tracked = listening && typeof listening.getAttribute === 'function' && (listening.id || listening.name) ? listening : event.target; + if (tracked.id || tracked.name) { + var targetId = tracked.id ? tracked.id : tracked.name; + + // The click the tracker dispatches again once the event is sent: let it through + if (wem.eventsPrevented.indexOf(targetId) !== -1) { + return; + } + // Tracking is off, or Unomi could not be reached: nothing is sent, so leave the click alone + if (wem.fallback) { + return; + } + console.debug('[WEM] Send click event'); - var targetId = event.target.id ? event.target.id : event.target.name; + var clicked = event.target; var clickEvent = wem.buildEvent('click', - wem.buildTarget(targetId, event.target.localName), + wem.buildTarget(targetId, tracked.localName), wem.buildSourcePage()); - var eventIndex = wem.eventsPrevented.indexOf(targetId); - if (eventIndex !== -1) { - wem.eventsPrevented.splice(eventIndex, 0); - } else { - wem.eventsPrevented.push(targetId); - + // A click with a modifier key leaves the page open, and dispatching it again would lose + // the key. With a callback, the site handles the click itself, so it is still held back. + // A click the site already prevented is the site's: it is not dispatched again. + var mouseEvent = /** @type {MouseEvent} */(/** @type {unknown} */(event)); + var withModifier = mouseEvent.metaKey || mouseEvent.ctrlKey || mouseEvent.shiftKey || mouseEvent.altKey; + var holdBack = !event.defaultPrevented && elementLeavingPage(clicked) !== null && + !(withModifier && !successCallback && !errorCallback); + if (holdBack) { event.preventDefault(); + } - var target = event.target; - - wem.collectEvent(clickEvent, function (xhr) { - console.debug('[WEM] Click event successfully collected.'); - if (successCallback) { - successCallback(xhr); - } else { - target.click(); + // Dispatch the click again, on the clicked element and to the whole page as for the + // visitor's click: single-page application routers ignore the visitor's click, which + // is prevented, and handle this one. click() runs at once, so the tracked element is + // only marked while it does. + var dispatchAgain = function () { + wem.eventsPrevented.push(targetId); + try { + clicked.click(); + } finally { + var index = wem.eventsPrevented.indexOf(targetId); + if (index !== -1) { + wem.eventsPrevented.splice(index, 1); } - }, function (xhr) { - console.error('[WEM] Could not send click event.'); - if (errorCallback) { - errorCallback(xhr); - } else { - target.click(); + } + }; + var once = settleOnce(); + /** + * Once the event is sent, or could not be: the site's callback, or the held back click + * @param {function(): void} log logs the outcome + * @param {Function} [callback] the site's callback for this outcome + * @returns {function(XMLHttpRequest=): void} the request callback, which only runs if nothing else settled + */ + var whenDone = function (log, callback) { + /** + * @param {XMLHttpRequest} [xhr] the request + * @returns {undefined} + */ + var settle = function (xhr) { + log(); + if (callback) { + callback(xhr); + } else if (holdBack) { + dispatchAgain(); } - }); + }; + return once(settle); + }; + var onSent = whenDone(function () { + console.debug('[WEM] Click event successfully collected.'); + }, successCallback); + var onNotSent = whenDone(function () { + console.error('[WEM] Could not send click event.'); + }, errorCallback); + + if (holdBack && wem.timeoutInMilliseconds === -1) { + setTimeout(whenDone(function () { + console.warn('[WEM] No answer from Unomi yet, the click goes on.'); + }, errorCallback), DEFAULT_TIMEOUT_IN_MILLISECONDS); + } + try { + wem.collectEvent(clickEvent, onSent, onNotSent); + } catch (e) { + // Go on once the visitor's click is done: a click dispatched during it can be ignored + console.error('[WEM] Could not send click event:', e); + setTimeout(function () { + onNotSent(undefined); + }, 0); } } }, @@ -1261,35 +1476,84 @@ export const newTracker = () => { var form = event.target; var formName = form.getAttribute('name') ? form.getAttribute('name') : form.getAttribute('id'); if (formName && wem.formNamesToWatch.indexOf(formName) > -1) { + // Tracking is off, or Unomi could not be reached: nothing is sent, so leave the submit alone + if (wem.fallback) { + return; + } console.debug('[WEM] catching form ' + formName); - var eventCopy = document.createEvent('Event'); - // Define that the event name is 'build'. - eventCopy.initEvent('submit', event.bubbles, event.cancelable); + // The button that submitted the form, if any: the submitted data must include it + var submitter = /** @type {HTMLButtonElement | HTMLInputElement | null} */(event.submitter || null); + + // A submit the site already prevented (it sends the form itself), or into another tab + // or window: the page stays, so only send the event + var formTarget = (submitter && submitter.getAttribute('formtarget')) || form.getAttribute('target'); + if (event.defaultPrevented || !opensInThisPage(formTarget)) { + try { + wem.collectEvent(wem.buildFormEvent(formName, form)); + } catch (e) { + console.error('[WEM] Could not send form event:', e); + } + return; + } event.stopImmediatePropagation(); event.preventDefault(); - wem.collectEvent(wem.buildFormEvent(formName, form), - function () { - form.removeEventListener('submit', wem._formSubmitEventListener, true); - form.dispatchEvent(eventCopy); - if (!eventCopy.defaultPrevented && !eventCopy.cancelBubble) { - form.submit(); + // Once the event is sent, or could not be: submit the form again, without the tracker's + // listener. The site's handlers see that submit, and it does not go on if one of them + // prevents it. The HTMLFormElement methods are called directly, as a field named + // "submit" or "requestSubmit" hides the form's own. + var continueSubmit = function () { + form.removeEventListener('submit', wem._formSubmitEventListener, true); + try { + // As a native submit: the submit event, then the data with the button. It + // refuses a button that is no longer in the form (the site removed or replaced + // it meanwhile), before doing anything: then submit the form as older browsers do. + var submitted = false; + if (typeof HTMLFormElement.prototype.requestSubmit === 'function') { + try { + HTMLFormElement.prototype.requestSubmit.call(form, submitter); + submitted = true; + } catch (e) { + console.debug('[WEM] requestSubmit refused the form ' + formName + ', submitting it without: ' + e); + } } - form.addEventListener('submit', wem._formSubmitEventListener, true); - }, - function (xhr) { - console.error('[WEM] Error while collecting form event: ' + xhr.status + ' ' + xhr.statusText); - xhr.abort(); - form.removeEventListener('submit', wem._formSubmitEventListener, true); - form.dispatchEvent(eventCopy); - if (!eventCopy.defaultPrevented && !eventCopy.cancelBubble) { - form.submit(); + if (!submitted) { + submitWithoutRequestSubmit(form, submitter); } + } catch (e) { + console.error('[WEM] Could not submit form ' + formName + ':', e); + } finally { form.addEventListener('submit', wem._formSubmitEventListener, true); } - ); + }; + // Submit once: when the event is sent, when it could not be (also when sending it + // throws), or, without a request timeout, after 1.5s at most + var once = settleOnce(); + var onSent = once(continueSubmit); + var onNotSent = once(function (xhr) { + console.error('[WEM] Error while collecting form event' + (xhr ? ': ' + xhr.status + ' ' + xhr.statusText : '')); + if (xhr) { + xhr.abort(); + } + continueSubmit(); + }); + if (wem.timeoutInMilliseconds === -1) { + setTimeout(once(function () { + console.warn('[WEM] No answer from Unomi yet, the form is submitted.'); + continueSubmit(); + }), DEFAULT_TIMEOUT_IN_MILLISECONDS); + } + try { + wem.collectEvent(wem.buildFormEvent(formName, form), onSent, onNotSent); + } catch (e) { + // Go on once the visitor's submit is done: browsers ignore a submit made during it + console.error('[WEM] Could not send form event:', e); + setTimeout(function () { + onNotSent(undefined); + }, 0); + } } }, @@ -1362,11 +1626,12 @@ export const newTracker = () => { * @private */ _resolveId: function (id) { - if (wem.digitalData.sourceLocalIdentifierMap) { - var source = Object.keys(wem.digitalData.sourceLocalIdentifierMap).filter(function (source) { - return id.indexOf(source) > 0; + var map = /** @type {Record<string, string> | undefined} */(wem.digitalData.sourceLocalIdentifierMap); + if (map) { + var sources = Object.keys(map).filter(function (source) { + return id.indexOf(source) !== -1; }); - return source ? id.replace(source, wem.digitalData.sourceLocalIdentifierMap[source]) : id; + return sources.length > 0 ? id.replace(sources[0], map[sources[0]]) : id; } return id; }, diff --git a/test/servers/README.md b/test/servers/README.md index 241ea54..72f9a6f 100644 --- a/test/servers/README.md +++ b/test/servers/README.md @@ -44,6 +44,35 @@ The command builds the tracker and compares its requests with those of the publi for each server, it starts the server, creates the scope `tracker-test`, runs the tests and removes the server with its data. It exits with an error if anything fails. +Browsers +-------- +The tests run in Chromium by default. `TRACKER_BROWSERS` chooses others, comma-separated: +`chromium`, `firefox`, and `webkit` (Playwright's build of Safari's engine). Install them once with +`npx playwright install firefox webkit`. + +```shell +TRACKER_BROWSERS=chromium,firefox,webkit yarn test:servers unomi3 +``` + +WebKit is not Safari: popup blocking, how long a click still counts as the visitor's own, and +cookie rules (Intelligent Tracking Prevention) belong to Safari. `yarn test:safari` checks the +tracker in the real Safari of a Mac, against a Unomi simulated in Node (no Docker): links followed +once the event is sent, also when the visitor clicks inside a link; new tabs opened while Unomi is +slow; Cmd+click; single-page application routers; site click handlers run once; links followed +when Unomi cannot be reached or never answers; forms submitted with their button, in browsers with +and without `requestSubmit`. `yarn test:safari --tracker <file>` runs the same checks with another +build, for example to compare with the previous release, and `--only <text>` only the checks whose +question contains the text. + +Once, on the Mac: `sudo safaridriver --enable`, then in Safari, Settings > Advanced > Show +features for web developers, and Develop > Allow Remote Automation. + +Safari drops automated clicks on a hidden page (display asleep, screen locked, window hidden), so +each check runs in a Safari session of its own, the display is kept awake during the run, and the +run stops with no result (exit code 2) if the page is hidden anyway. A click the page did not get +is clicked again, and a check whose clicks were dropped runs once more; both are shown in the +output. A failing check also shows what Unomi got, the page's address and the tracker's logs. + Servers ------- | Name | Server | Search engine | @@ -70,6 +99,38 @@ For each server: Non-empty `attributes` are sent as before; no default page schema accepts them, so the server drops the event, as with 1.5.0. Unomi 2.0 to 2.3 accept an empty one; 2.4 and later reject it too (UNOMI-790). +- Personalization: Unomi chooses the variant whose condition matches, and the tracker displays it. + When Unomi cannot be reached, or does not answer within `timeoutInMilliseconds`, the tracker + falls back and displays the fallback variant. +- A configuration without `timeoutInMilliseconds` loads the context and sends events (UNOMI-1043). +- Clicks sent with `sendClickEvent` (UNOMI-1037), on a button and on a link, as an event listener + and with callbacks: every click is stored, also a second click made before the first event is + sent, and none twice. When the event cannot be sent, the error callback is called, or a link is + still followed. The site's own click handler runs once per click on a button, and single-page + application routers, on the document or on the link itself, handle a tracked link once per + click without reloading the page (UNOMI-1046). +- A click on a child of a tracked link or button (an image, an icon, some text), with or without + its own id, is stored on the tracked element; the link waits for the event, then is followed + (UNOMI-1047). +- Links and forms do not wait for Unomi when they keep the page: a link to a new tab, a download, a + form submitted into a new tab; Ctrl or Cmd+click opens a new tab, and the click is still stored + (UNOMI-1041). They still work at once when Unomi could not be reached, when tracking is turned + off (`_enableWem(false)`), or when the event cannot even be sent; without a timeout, they wait + 1.5s at most for a Unomi that never answers (UNOMI-1040). +- A form: the setup adds a rule on its submit, so Unomi returns it in the tracked conditions and + the tracker watches it. On submit, the form event is stored with the field values (text, text + area, checked checkboxes and radio button, selected options; empty fields are left out). The + site's own submit handler runs once, once the event is sent or could not be, and learns which + button was used. A form the site lets submit sends the same data as a native submit, with the + button that was used (also one named `submit`, an image button, one the site removes meanwhile), + in browsers with and without `requestSubmit` (UNOMI-1042), also with Enter, when the event cannot + be sent, and at once when tracking is turned off (UNOMI-1040). A click on a tracked submit button + of a tracked form stores the click and the form event. + +Not tested yet: optimization tests, search and video events, `invalidateSessionAndProfile`, +digitalData overrides, personalization with a control group or a result callback, and a site and +Unomi on different domains (the test origins are all on localhost, which browsers treat as one +site). Files ----- diff --git a/test/servers/page/index.html b/test/servers/page/index.html index b7e35d8..8ba2f6f 100644 --- a/test/servers/page/index.html +++ b/test/servers/page/index.html @@ -42,16 +42,55 @@ // noBufferShim load the tracker without the Buffer shim (optional) // pageAttributes digitalData.page.attributes as JSON, for example {} (optional) // sessionId session ID to use instead of a new one (optional) + // timeout wemInitConfig.timeoutInMilliseconds (optional, 10000 by default); "none" leaves it + // out of the configuration + // personalization "true": a personalized area with three variants (optional) + // clickButton id of a button whose clicks are sent with sendClickEvent (optional) + // clickLink the element is a link instead of a button: "true" to /arrived; "hash" to #arrived, + // which keeps the page open; "blank" to /arrived in a new tab; "download" to /arrived + // as a download (optional) + // clickChild "plain" or "withId": the visitor clicks a child of the element, without or with + // its own id, as an image or an icon inside a link (optional) + // clickCallback "true": the element passes success and error callbacks to sendClickEvent (optional) + // form name of a form, watched by the tracker when Unomi tracks it (optional) + // formSubmit "native": the site lets the form submit to /submitted, instead of handling it (optional) + // router a stand-in for a single-page application router, which handles the link clicks + // nobody prevented yet: "true" listens on the document (React Router listens on the + // application's root), "link" on the link itself before the tracker (as Vue Router's + // RouterLink) (optional) + // formTarget the form's target, for example "_blank" (optional) + // trackSubmitButton "true": the clicks on the form's "delete" button are sent with sendClickEvent (optional) + // oldBrowser "true": no HTMLFormElement.requestSubmit nor SubmitEvent, as in older browsers (optional) (function () { const params = new URLSearchParams(document.location.search); + if (params.get('oldBrowser') === 'true') { + delete HTMLFormElement.prototype.requestSubmit; + delete window.SubmitEvent; + } + // Changes with each page load: the same value after a click shows the page was not reloaded + const pageLoadId = Math.random(); + let routed = 0; + if (params.get('router') === 'true') { + document.addEventListener('click', function (event) { + const link = event.target.closest && event.target.closest('a'); + if (link && !event.defaultPrevented) { + event.preventDefault(); + history.pushState({}, '', link.getAttribute('href')); + routed++; + } + }); + } const wemInitConfig = { contextServerUrl: params.get('unomi'), - timeoutInMilliseconds: 10000, + timeoutInMilliseconds: params.has('timeout') ? Number(params.get('timeout')) : 10000, contextServerCookieName: 'context-profile-id', activateWem: true, trackerSessionIdCookieName: 'tracker-test-session-id', trackerProfileIdCookieName: 'tracker-test-profile-id' }; + if (params.get('timeout') === 'none') { + delete wemInitConfig.timeoutInMilliseconds; + } const digitalData = { scope: 'tracker-test', site: { siteInfo: { siteID: 'tracker-test' } }, @@ -85,7 +124,174 @@ // initTracker replaces the tracker configuration, so register the callback after it tracker.initTracker(digitalData); + // A personalized area: Unomi picks "always" (its condition always matches) over "never" (its + // condition never matches); "fallback" is shown when Unomi cannot be reached. + const personalizedArea = document.createElement('div'); + if (params.get('personalization') === 'true') { + personalizedArea.id = 'tracker-test-personalization'; + ['never', 'always', 'fallback'].forEach(function (name) { + const variant = document.createElement('div'); + variant.id = 'variant-' + name; + variant.textContent = name; + personalizedArea.appendChild(variant); + }); + document.body.appendChild(personalizedArea); + tracker.registerPersonalizationObject({ + id: personalizedArea.id, + strategy: 'matching-first', + strategyOptions: { fallback: 'fallback' }, + contents: [ + { id: 'never', filters: [{ condition: { type: 'profilePropertyCondition', parameterValues: { propertyName: 'properties.trackerTestNever', comparisonOperator: 'exists' } } }] }, + { id: 'always', filters: [{ condition: { type: 'matchAllCondition', parameterValues: {} } }] } + ] + }, { + never: { content: 'variant-never', position: 0 }, + always: { content: 'variant-always', position: 1 }, + fallback: { content: 'variant-fallback', position: 2 } + }); + } + + // A button or a link sending its clicks the way the Unomi manual shows, or with callbacks, as a + // site does when it handles the click itself once the event is sent + const clickCallbacks = { success: 0, error: 0 }; + let siteClicks = 0; + if (params.has('clickButton')) { + const element = document.createElement(params.has('clickLink') ? 'a' : 'button'); + element.id = params.get('clickButton'); + if (element.tagName === 'A') { + const kind = params.get('clickLink'); + element.href = kind === 'hash' ? '#arrived' : '/arrived'; + if (kind === 'blank') { + element.target = '_blank'; + } else if (kind === 'download') { + element.setAttribute('download', 'arrived.html'); + } + } else { + element.type = 'button'; + } + element.textContent = 'Tracked element'; + if (params.has('clickChild')) { + const child = document.createElement('span'); + child.className = 'tracked-child'; + child.textContent = ' (child)'; + if (params.get('clickChild') === 'withId') { + child.id = element.id + '-child'; + } + element.appendChild(child); + } + if (params.get('router') === 'link') { + element.addEventListener('click', function (event) { + if (!event.defaultPrevented) { + event.preventDefault(); + history.pushState({}, '', element.getAttribute('href')); + routed++; + } + }); + } + // The site's own click handler, registered before the tracker's + element.addEventListener('click', function () { + siteClicks++; + }); + if (params.get('clickCallback') === 'true') { + element.addEventListener('click', function (event) { + tracker.sendClickEvent(event, function () { + clickCallbacks.success++; + }, function () { + clickCallbacks.error++; + }); + }); + } else { + element.addEventListener('click', tracker.sendClickEvent); + } + document.body.appendChild(element); + } + + // A form with the usual fields, several submit buttons (one named "submit", one the site removes + // after the click) and an image button. The site handles the submit itself (like + // a form sent with JavaScript), so the page stays open, or with formSubmit=native lets it go to + // /submitted. The tracker stops the visitor's own submit and sends the form event; the site's + // handler then only gets the submit the tracker makes once the event is sent. + const siteSubmits = []; + if (params.has('form')) { + const form = document.createElement('form'); + form.setAttribute('name', params.get('form')); + form.action = '/submitted'; + form.method = 'get'; + form.innerHTML = '<input type="email" name="email" value="[email protected]">' + + '<input type="checkbox" name="topics" value="news" checked>' + + '<input type="checkbox" name="topics" value="offers">' + + '<select name="country"><option value="fr">France</option><option value="ch" selected>Switzerland</option></select>' + + '<select name="languages" multiple><option value="fr" selected>French</option><option value="de" selected>German</option><option value="it">Italian</option></select>' + + '<input type="radio" name="contact" value="email" checked><input type="radio" name="contact" value="phone">' + + '<textarea name="message">Hello</textarea>' + + '<input type="text" name="company" value="">' + + '<button type="submit" id="submit-form" name="action" value="send">Send</button>' + + '<button type="submit" id="delete-form" name="action" value="delete">Delete</button>' + // A button named "submit" hides the form's own submit() + + '<button type="submit" id="submit-named" name="submit" value="go">Go</button>' + // The site takes this button out of the form right after the click + + '<button type="submit" id="submit-removed" name="action" value="removed">Done</button>' + + '<input type="image" id="submit-image" name="pic" alt="Send" width="20" height="20" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7">'; + form.addEventListener('submit', function (event) { + if (params.get('formSubmit') !== 'native') { + event.preventDefault(); + } + siteSubmits.push({ submitter: event.submitter ? event.submitter.id : null }); + }); + if (params.has('formTarget')) { + form.target = params.get('formTarget'); + } + if (params.get('trackSubmitButton') === 'true') { + form.querySelector('#delete-form').addEventListener('click', tracker.sendClickEvent); + } + form.querySelector('#submit-removed').addEventListener('click', function (event) { + setTimeout(function () { + event.target.remove(); + }, 0); + }); + document.body.appendChild(form); + } + window.trackerTest = { + // The variants of the personalized area that are displayed + shownVariants: function () { + return Array.prototype.filter.call(personalizedArea.children, function (variant) { + return variant.style.display !== 'none'; + }).map(function (variant) { + return variant.id; + }); + }, + // The submits the site's own handler received + siteSubmits: function () { + return siteSubmits; + }, + // Whether the page is still the one first loaded, and how many link clicks the router handled + pageLoadId: function () { + return pageLoadId; + }, + routed: function () { + return routed; + }, + // How many times the site's own click handler ran on the element + siteClicks: function () { + return siteClicks; + }, + // How many times sendClickEvent called the element's success and error callbacks + clickCallbacks: function () { + return clickCallbacks; + }, + // Makes sending the next events throw at once (the request cannot even be opened) + breakServerUrl: function () { + tracker.contextServerUrl = 'http://['; + }, + // Turns tracking off, as a site does when the visitor withdraws consent + disableTracking: function () { + tracker._enableWem(false); + }, + // The forms the tracker watches (those Unomi returned in the tracked conditions) + watchedForms: function () { + return tracker.getFormNamesToWatch(); + }, // Resolves once the context is loaded, or once the tracker falls back after an error context: new Promise(function (resolve) { tracker._registerCallback(function () { diff --git a/test/servers/playwright.config.js b/test/servers/playwright.config.js index 579b376..692ac77 100644 --- a/test/servers/playwright.config.js +++ b/test/servers/playwright.config.js @@ -17,9 +17,24 @@ // Browser tests of the tracker against one running Unomi server. Run them through // `yarn test:servers`, which starts each server and sets UNOMI_TARGET. +// TRACKER_BROWSERS chooses the browsers, comma-separated: chromium (the default), firefox, webkit +// (Playwright's build of Safari's engine). const path = require('path'); const { defineConfig } = require('@playwright/test'); +const BROWSERS = { + // The tracker treats a "HeadlessChrome" user agent as a crawler and does not start + chromium: { browserName: 'chromium', userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36' }, + firefox: { browserName: 'firefox' }, + webkit: { browserName: 'webkit' } +}; +const browsers = (process.env.TRACKER_BROWSERS || 'chromium').split(',').map(name => name.trim()).filter(Boolean); +for (const name of browsers) { + if (!BROWSERS[name]) { + throw new Error('Unknown browser "' + name + '" in TRACKER_BROWSERS, expected: ' + Object.keys(BROWSERS).join(', ')); + } +} + module.exports = defineConfig({ testDir: __dirname, testMatch: 'tracker.spec.js', @@ -28,11 +43,7 @@ module.exports = defineConfig({ workers: 1, reporter: 'list', globalSetup: require.resolve('./global-setup.js'), - use: { - browserName: 'chromium', - // The tracker treats a "HeadlessChrome" user agent as a crawler and does not start - userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36' - }, + projects: browsers.map(name => ({ name, use: BROWSERS[name] })), webServer: { command: 'node ' + JSON.stringify(path.join(__dirname, 'serve.js')), url: 'http://localhost:8000/', diff --git a/test/servers/safari.js b/test/servers/safari.js new file mode 100644 index 0000000..019f527 --- /dev/null +++ b/test/servers/safari.js @@ -0,0 +1,475 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Checks the tracker in the real Safari of this Mac, where Playwright's WebKit can differ (popup +// blocking, how long a click counts as the visitor's own, cookies). Safari is driven through +// safaridriver (WebDriver), whose clicks are real user clicks. Unomi is simulated here, so no +// Docker is needed: it can answer, answer late, never answer, or refuse connections, and it +// counts the events it gets. +// +// yarn test:safari the current build (dist), built first +// yarn test:safari --tracker <file> another build of apache-unomi-tracker.umd.js +// yarn test:safari --only <text> only the checks whose question contains the text +// +// Once, on the Mac: `sudo safaridriver --enable`, then in Safari, Settings > Advanced > Show +// features for web developers, and Develop > Allow Remote Automation. +const http = require('http'); +const path = require('path'); +const fs = require('fs'); +const { spawn, spawnSync } = require('child_process'); + +const DRIVER_PORT = 4445; +const UNOMI_PORT = 8282; +const UNOMI = 'http://localhost:' + UNOMI_PORT; +const SITE = 'http://localhost:8000'; +const FORM_NAME = 'tracker-test-form'; +const ELEMENT = 'element-6066-11e4-a52e-4f735466cecf'; +const KEYS = { meta: '' }; + +const args = process.argv.slice(2); +const trackerArg = args.indexOf('--tracker'); +const trackerFile = trackerArg !== -1 ? path.resolve(args[trackerArg + 1]) : null; +const onlyArg = args.indexOf('--only'); +const only = onlyArg !== -1 ? args[onlyArg + 1].toLowerCase() : null; + +// --- Simulated Unomi ------------------------------------------------------------------------- + +const unomi = { mode: 'answer', delayMs: 0, events: [], requests: [] }; + +function corsHeaders(request) { + return { + 'Access-Control-Allow-Origin': request.headers.origin || '*', + 'Access-Control-Allow-Credentials': 'true', + 'Access-Control-Allow-Headers': 'Content-Type, X-Unomi-Api-Key', + 'Access-Control-Allow-Methods': 'POST, OPTIONS' + }; +} + +const unomiServer = http.createServer((request, response) => { + if (request.method === 'OPTIONS') { + response.writeHead(204, corsHeaders(request)).end(); + return; + } + let body = ''; + request.on('data', chunk => body += chunk); + request.on('end', () => { + const url = new URL(request.url, UNOMI); + unomi.requests.push(request.method + ' ' + url.pathname + (url.pathname === '/eventcollector' ? ' (' + unomi.mode + ')' : '')); + if (url.pathname === '/context.json') { + response.writeHead(200, Object.assign({ 'Content-Type': 'application/json' }, corsHeaders(request))); + response.end(JSON.stringify({ + profileId: 'safari-profile', + sessionId: 'safari-session', + trackedConditions: [{ type: 'formEventCondition', parameterValues: { formId: FORM_NAME } }] + })); + return; + } + if (url.pathname === '/eventcollector') { + if (unomi.mode === 'refuse') { + request.socket.destroy(); + return; + } + if (unomi.mode === 'never') { + return; + } + const answer = () => { + try { + unomi.events.push(...JSON.parse(body).events); + } catch (e) { + // not an event list + } + response.writeHead(200, Object.assign({ 'Content-Type': 'application/json' }, corsHeaders(request))); + response.end('{}'); + }; + setTimeout(answer, unomi.delayMs); + return; + } + response.writeHead(404, corsHeaders(request)).end(); + }); +}); + +function setUnomi(mode, delayMs = 0) { + unomi.mode = mode; + unomi.delayMs = delayMs; + unomi.events = []; + unomi.requests = []; +} + +// --- WebDriver --------------------------------------------------------------------------------- + +let session; +// The clicks Safari dropped, clicked again +const retriedClicks = []; + +async function driver(method, endpoint, body) { + const response = await fetch('http://localhost:' + DRIVER_PORT + endpoint, { + method, + headers: { 'Content-Type': 'application/json' }, + body: body === undefined ? undefined : JSON.stringify(body) + }); + const result = await response.json(); + if (!response.ok) { + throw new Error(method + ' ' + endpoint + ': ' + JSON.stringify(result.value)); + } + return result.value; +} + +const safari = { + open: url => driver('POST', '/session/' + session + '/url', { url }), + url: () => driver('GET', '/session/' + session + '/url'), + run: (script, ...scriptArgs) => driver('POST', '/session/' + session + '/execute/sync', { script, args: scriptArgs }), + runAsync: (script, ...scriptArgs) => driver('POST', '/session/' + session + '/execute/async', { script, args: scriptArgs }), + find: async selector => (await driver('POST', '/session/' + session + '/element', { using: 'css selector', value: selector }))[ELEMENT], + clickOnce: async selector => driver('POST', '/session/' + session + '/element/' + await safari.find(selector) + '/click', {}), + // Safari sometimes drops a WebDriver click (after a tab was closed, the page may not have the + // focus yet): click again if the page saw no click and did not change, and say so + click: async selector => { + for (let attempt = 1; ; attempt++) { + const before = await safari.url(); + const clicksBefore = await safari.run('return window.harnessClicks || 0;'); + await safari.clickOnce(selector); + const delivered = await waitFor(async () => await safari.url() !== before || await safari.run('return window.harnessClicks || 0;') > clicksBefore, 1000); + if (delivered || attempt === 2) { + return; + } + // Whether the page had the focus and was visible: Safari drops clicks when it has not + const state = await safari.run('return (document.hasFocus() ? "focused" : "not focused") + ", " + document.visibilityState;'); + retriedClicks.push(selector + ' (page ' + state + ')'); + } + }, + clickWithKey: async (selector, key) => { + const element = await safari.find(selector); + await driver('POST', '/session/' + session + '/actions', { + actions: [ + { type: 'key', id: 'keyboard', actions: [{ type: 'keyDown', value: key }, { type: 'pause', duration: 0 }, { type: 'pause', duration: 0 }, { type: 'keyUp', value: key }] }, + { type: 'pointer', id: 'mouse', parameters: { pointerType: 'mouse' }, actions: [{ type: 'pointerMove', origin: { [ELEMENT]: element }, x: 0, y: 0 }, { type: 'pointerDown', button: 0 }, { type: 'pointerUp', button: 0 }, { type: 'pause', duration: 0 }] } + ] + }); + await driver('DELETE', '/session/' + session + '/actions'); + }, + windows: () => driver('GET', '/session/' + session + '/window/handles'), + switchTo: handle => driver('POST', '/session/' + session + '/window', { handle }), + closeWindow: () => driver('DELETE', '/session/' + session + '/window') +}; + +async function closeOtherWindows(keep) { + for (const handle of await safari.windows()) { + if (handle !== keep) { + await safari.switchTo(handle); + await safari.closeWindow(); + } + } + await safari.switchTo(keep); +} + +// --- Checks ------------------------------------------------------------------------------------ + +const sleep = ms => new Promise(resolve => setTimeout(resolve, ms)); + +class PageHidden extends Error { + constructor() { + super('Safari\'s page is hidden: the display is asleep, the screen is locked, or the window cannot be seen'); + } +} + +async function waitFor(condition, timeoutMs) { + const deadline = Date.now() + timeoutMs; + for (;;) { + const value = await condition(); + if (value || Date.now() > deadline) { + return value; + } + await sleep(100); + } +} + +// Opens the test page with the given options and waits for the tracker to load the context. It +// starts from a blank page, and waits for the test page itself: a navigation left over from the +// previous check (a link followed late) must not land on this one. +async function openPage(params) { + await safari.open('about:blank'); + await sleep(500); + const query = new URLSearchParams(Object.assign({ unomi: UNOMI, sessionId: 'safari-session-' + Date.now() }, params)); + const url = SITE + '/?' + query; + await safari.open(url); + const ready = await waitFor(async () => await safari.url() === url && await safari.run('return !!(window.trackerTest && window.trackerTest.context);'), 5000); + if (!ready) { + throw new Error('The test page did not load: at ' + await safari.url()); + } + // Count the clicks the page sees, and keep what the tracker logs from now on, to explain a failure + await safari.run(`window.harnessClicks = 0; + window.addEventListener('click', () => window.harnessClicks++, true); + window.trackerLogs = []; + ['debug', 'info', 'log', 'warn', 'error'].forEach(level => { + const original = console[level]; + console[level] = function () { + window.trackerLogs.push(level + ': ' + Array.prototype.join.call(arguments, ' ')); + return original.apply(console, arguments); + }; + });`); + // Let Safari give the page the focus before the first click. Safari drops the clicks on a + // hidden page (display asleep, screen locked, window hidden): that is no tracker result. + await sleep(300); + if (await safari.run('return document.visibilityState;') === 'hidden') { + throw new PageHidden(); + } + return safari.runAsync('const done = arguments[arguments.length - 1]; window.trackerTest.context.then(done);'); +} + +const pathOf = async () => new URL(await safari.url()).pathname; +const eventsOn = targetId => unomi.events.filter(event => event.target && event.target.itemId === targetId); + +const checks = [ + { + question: 'A tracked link is followed once its event is sent', + async run() { + setUnomi('answer', 300); + await openPage({ clickButton: 'link', clickLink: 'true' }); + await safari.click('#link'); + const arrived = await waitFor(async () => await pathOf() === '/arrived', 5000); + return { ok: arrived && eventsOn('link').length === 1, details: 'followed: ' + arrived + ', events: ' + eventsOn('link').length }; + } + }, + { + question: 'A click on an image or text inside a tracked link is tracked, and the link followed', + async run() { + setUnomi('answer', 300); + await openPage({ clickButton: 'link', clickLink: 'true', clickChild: 'plain' }); + await safari.click('#link .tracked-child'); + const arrived = await waitFor(async () => await pathOf() === '/arrived', 5000); + return { ok: arrived && eventsOn('link').length === 1, details: 'followed: ' + arrived + ', events on the link: ' + eventsOn('link').length }; + } + }, + { + question: 'A link to a new tab opens it while Unomi is slow (3s), with no popup blocked', + async run(main) { + setUnomi('answer', 3000); + await openPage({ clickButton: 'blank', clickLink: 'blank' }); + const before = (await safari.windows()).length; + await safari.click('#blank'); + const opened = await waitFor(async () => (await safari.windows()).length > before, 5000); + await waitFor(async () => eventsOn('blank').length === 1, 5000); + await closeOtherWindows(main); + return { ok: opened && eventsOn('blank').length === 1, details: 'new tab: ' + opened + ', events: ' + eventsOn('blank').length }; + } + }, + { + question: 'Cmd+click on a tracked link opens a new tab and keeps the page', + async run(main) { + setUnomi('answer', 300); + await openPage({ clickButton: 'link', clickLink: 'true' }); + const before = (await safari.windows()).length; + await safari.clickWithKey('#link', KEYS.meta); + const opened = await waitFor(async () => (await safari.windows()).length > before, 3000); + const stayed = await pathOf() === '/'; + await waitFor(async () => eventsOn('link').length === 1, 3000); + await closeOtherWindows(main); + return { ok: opened && stayed && eventsOn('link').length === 1, details: 'new tab: ' + opened + ', page kept: ' + stayed + ', events: ' + eventsOn('link').length }; + } + }, + { + question: 'A single-page application router (on the document) handles a tracked link without a reload', + async run() { + setUnomi('answer', 300); + await openPage({ clickButton: 'link', clickLink: 'true', router: 'true' }); + const loadId = await safari.run('return window.trackerTest.pageLoadId();'); + await safari.click('#link'); + const routed = await waitFor(() => safari.run('return window.trackerTest.routed();'), 5000); + const sameLoad = await safari.run('return window.trackerTest.pageLoadId();') === loadId; + return { ok: routed === 1 && sameLoad, details: 'routed: ' + routed + ', no reload: ' + sameLoad }; + } + }, + { + question: 'A router on the link itself (as Vue Router) handles each click once', + async run() { + setUnomi('answer', 300); + await openPage({ clickButton: 'link', clickLink: 'true', router: 'link' }); + await safari.click('#link'); + await waitFor(async () => eventsOn('link').length === 1, 3000); + await sleep(700); + const routed = await safari.run('return window.trackerTest.routed();'); + return { ok: routed === 1, details: 'routed: ' + routed }; + } + }, + { + question: 'A site click handler on a tracked button runs once per click', + async run() { + setUnomi('answer', 300); + await openPage({ clickButton: 'button' }); + await safari.click('#button'); + await waitFor(async () => eventsOn('button').length === 1, 3000); + await sleep(500); + const handled = await safari.run('return window.trackerTest.siteClicks();'); + return { ok: handled === 1, details: 'site handler runs: ' + handled }; + } + }, + { + question: 'A link is followed at once when Unomi could not be reached', + async run() { + setUnomi('refuse'); + const context = await openPage({ clickButton: 'link', clickLink: 'true', unomi: 'http://localhost:1' }); + await safari.click('#link'); + const arrived = await waitFor(async () => await pathOf() === '/arrived', 3000); + return { ok: !context.loaded && arrived, details: 'context loaded: ' + context.loaded + ', followed: ' + arrived }; + } + }, + { + question: 'A link is followed within 1.5s when Unomi never answers and there is no timeout', + async run() { + setUnomi('never'); + await openPage({ clickButton: 'link', clickLink: 'true', timeout: '-1' }); + const start = Date.now(); + await safari.click('#link'); + const arrived = await waitFor(async () => await pathOf() === '/arrived', 5000); + const elapsed = Date.now() - start; + return { ok: arrived && elapsed >= 1400, details: 'followed: ' + arrived + ' after ' + elapsed + 'ms' }; + } + }, + ...[ + { name: 'its button', button: 'delete-form', expect: { action: 'delete' } }, + { name: 'a button named "submit"', button: 'submit-named', expect: { submit: 'go' } }, + { name: 'an image button', button: 'submit-image', expect: { 'pic.x': /^\d+$/ } } + ].flatMap(form => [false, true].map(oldBrowser => ({ + question: 'A tracked form is submitted with ' + form.name + (oldBrowser ? ', without requestSubmit' : ''), + async run() { + setUnomi('answer', 300); + await openPage(Object.assign({ form: FORM_NAME, formSubmit: 'native' }, oldBrowser ? { oldBrowser: 'true' } : {})); + await safari.click('#' + form.button); + const submitted = await waitFor(async () => await pathOf() === '/submitted', 5000); + const sent = new URL(await safari.url()).searchParams; + const fields = Object.keys(form.expect).every(name => { + const value = sent.get(name); + return value !== null && (form.expect[name] instanceof RegExp ? form.expect[name].test(value) : value === form.expect[name]); + }); + const formEvents = unomi.events.filter(event => event.eventType === 'form').length; + return { ok: submitted && fields && formEvents === 1, details: 'submitted: ' + submitted + ', ' + sent.toString() + ', form events: ' + formEvents }; + } + }))), + { + question: 'Safari has requestSubmit and SubmitEvent', + async run() { + await openPage({}); + const support = await safari.run('return { requestSubmit: typeof HTMLFormElement.prototype.requestSubmit, SubmitEvent: typeof SubmitEvent };'); + return { ok: support.requestSubmit === 'function' && support.SubmitEvent === 'function', details: JSON.stringify(support) }; + } + } +]; + +// --- Run --------------------------------------------------------------------------------------- + +async function main() { + const root = path.join(__dirname, '..', '..'); + if (!trackerFile && spawnSync('yarn', ['build'], { cwd: root, stdio: 'inherit' }).status !== 0) { + process.exit(1); + } + const env = Object.assign({}, process.env, trackerFile ? { TRACKER_FILE: trackerFile } : {}); + const page = spawn('node', [path.join(__dirname, 'serve.js')], { env, stdio: 'ignore' }); + const safaridriver = spawn('/usr/bin/safaridriver', ['-p', String(DRIVER_PORT)], { stdio: 'ignore' }); + await new Promise(resolve => unomiServer.listen(UNOMI_PORT, resolve)); + const stop = () => { + page.kill(); + safaridriver.kill(); + unomiServer.close(); + if (awake) { + awake.kill(); + } + }; + // Keep the display awake, and wake it, while the checks run: Safari drops clicks on a hidden page + const awake = fs.existsSync('/usr/bin/caffeinate') ? spawn('/usr/bin/caffeinate', ['-d', '-u'], { stdio: 'ignore' }) : null; + try { + await sleep(1500); + // Each check in a session of its own: a tab a check opened and closed can leave Safari's window + // without the focus, and Safari then drops the clicks of the following checks + const startSession = async () => { + session = (await driver('POST', '/session', { capabilities: { alwaysMatch: { browserName: 'safari' } } })).sessionId; + return (await safari.windows())[0]; + }; + try { + await startSession(); + await driver('DELETE', '/session/' + session); + } catch (e) { + console.error('Could not start Safari through safaridriver: ' + e.message); + console.error('Once: `sudo safaridriver --enable`, then Safari > Develop > Allow Remote Automation.'); + process.exitCode = 2; + return; + } + console.log('Tracker: ' + (trackerFile || 'dist/apache-unomi-tracker.umd.js') + '\n'); + let failed = 0; + const selected = checks.filter(check => !only || check.question.toLowerCase().includes(only)); + for (const check of selected) { + let result; + let rerun = false; + // A check whose clicks Safari dropped tells nothing about the tracker: run it once more + for (let attempt = 1; attempt <= 2; attempt++) { + if (attempt === 2) { + await driver('DELETE', '/session/' + session); + rerun = true; + } + retriedClicks.length = 0; + const mainWindow = await startSession(); + try { + result = await check.run(mainWindow); + } catch (e) { + if (e instanceof PageHidden) { + throw e; + } + result = { ok: false, details: e.message }; + } + if (result.ok || !retriedClicks.length) { + break; + } + } + failed += result.ok ? 0 : 1; + console.log((result.ok ? 'PASS ' : 'FAIL ') + check.question + '\n ' + result.details); + if (rerun) { + console.log(' (run again: Safari dropped the clicks of the first run)'); + } + if (retriedClicks.length) { + console.log(' (Safari dropped a click on ' + retriedClicks.join(', ') + ', clicked again)'); + } + if (!result.ok) { + // What happened, to tell a tracker problem from a test or browser one + console.log(' Unomi got: ' + (unomi.requests.join(', ') || 'nothing')); + try { + console.log(' page: ' + await safari.url()); + const logs = await safari.run('return window.trackerLogs || null;'); + console.log(' tracker logs: ' + (logs ? logs.filter(line => line.includes('[WEM]')).join(' | ') || 'none' : 'not on this page (it was left)')); + } catch (e) { + console.log(' page: unavailable (' + e.message + ')'); + } + } + await driver('DELETE', '/session/' + session); + } + console.log('\n' + (selected.length - failed) + ' of ' + selected.length + ' passed'); + process.exitCode = failed ? 1 : 0; + } finally { + stop(); + } +} + +if (!fs.existsSync('/usr/bin/safaridriver')) { + console.error('safaridriver not found: these checks run on macOS, with Safari'); + process.exit(2); +} +main().catch(e => { + if (e instanceof PageHidden) { + console.error('\n' + e.message + '. The checks need a visible Safari window: stopped, no result.'); + process.exit(2); + } + console.error(e); + process.exit(1); +}); diff --git a/test/servers/serve.js b/test/servers/serve.js index f702eb4..45f4166 100644 --- a/test/servers/serve.js +++ b/test/servers/serve.js @@ -24,13 +24,24 @@ const path = require('path'); const PORTS = [8000, 8001]; const files = { '/': { file: path.join(__dirname, 'page', 'index.html'), type: 'text/html; charset=utf-8' }, - '/tracker.js': { file: path.join(__dirname, '..', '..', 'dist', 'apache-unomi-tracker.umd.js'), type: 'text/javascript; charset=utf-8' }, + // The current build, or another one given in TRACKER_FILE (safari.js --tracker) + '/tracker.js': { file: process.env.TRACKER_FILE || path.join(__dirname, '..', '..', 'dist', 'apache-unomi-tracker.umd.js'), type: 'text/javascript; charset=utf-8' }, // Downloaded by run.js, for the comparison with the published 1.5.0 '/tracker-1.5.0.js': { file: path.join(__dirname, '.cache', 'apache-unomi-tracker-1.5.0', 'package', 'dist', 'apache-unomi-tracker.umd.js'), type: 'text/javascript; charset=utf-8' } }; +// Where the test page's links and forms lead: a plain page (Firefox shows its own error page for +// an empty answer, and the tests then cannot see the address) +const DESTINATIONS = ['/arrived', '/submitted']; + function handle(request, response) { - const entry = files[new URL(request.url, 'http://localhost').pathname]; + const pathname = new URL(request.url, 'http://localhost').pathname; + if (DESTINATIONS.includes(pathname)) { + response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' }) + .end('<!DOCTYPE html><title>Arrived</title><p>Arrived</p>'); + return; + } + const entry = files[pathname]; if (!entry) { response.writeHead(404).end(); return; diff --git a/test/servers/tracker.spec.js b/test/servers/tracker.spec.js index 36d3a2c..b822cac 100644 --- a/test/servers/tracker.spec.js +++ b/test/servers/tracker.spec.js @@ -16,7 +16,7 @@ */ const { test, expect } = require('@playwright/test'); -const { UNOMI_URL, target, findClickEvents } = require('./unomi'); +const { UNOMI_URL, FORM_NAME, target, findEvents } = require('./unomi'); const server = target(process.env.UNOMI_TARGET); const LISTED_ORIGIN = 'http://localhost:8000'; @@ -41,20 +41,70 @@ async function openPage(page, origin, config, timeoutMs = 30000) { return { context, requests }; } +// An id no earlier test or run has used, so that the events found on it are this test's +function uniqueId(label) { + return label + '-' + Date.now() + '-' + Math.floor(Math.random() * 1e6); +} + +// Only the events of the page that loaded this context: a server kept from an earlier run can hold +// older ones on the same target +function thisSession(context) { + return event => event.sessionId === context.sessionId; +} + +// The events stored on the target, with the credentials that can read them +function events(targetId, options) { + return findEvents(process.env.UNOMI_READ_CREDENTIALS, targetId, options); +} + +// The form fields of the submitted page's address, as a native submit sends them: the form's +// fields, plus only the button that was used, with the expected values (strings or patterns) +function expectSubmitted(page, expectedButton) { + const sent = new URL(page.url()).searchParams; + expect(sent.get('email')).toBe('[email protected]'); + for (const name of ['action', 'submit', 'pic.x', 'pic.y']) { + const values = sent.getAll(name); + const expected = expectedButton[name] || []; + expect(values, name).toHaveLength(expected.length); + expected.forEach((value, index) => value instanceof RegExp ? expect(values[index]).toMatch(value) : expect(values[index]).toBe(value)); + } +} + +// Unomi does not answer the events until the test calls answer(): pending holds the waiting requests +async function holdEvents(page) { + const pending = []; + let answer; + const answered = new Promise(resolve => { + answer = resolve; + }); + await page.route(UNOMI_URL + '/eventcollector', async route => { + pending.push(route); + await answered; + await route.continue(); + }); + return { pending, answer: () => answer() }; +} + +// The count found by findEvents stays the same 2s later: no duplicate event arrives afterwards +async function expectNoMoreEvents(targetId, count, options = {}) { + await new Promise(resolve => setTimeout(resolve, 2000)); + expect(await events(targetId, Object.assign({}, options, { minCount: count + 1, timeoutMs: 1000 }))).toHaveLength(count); +} + async function sendClick(page, label) { - const targetId = label + '-' + Date.now() + '-' + Math.floor(Math.random() * 1e6); + const targetId = uniqueId(label); const result = await page.evaluate(id => window.trackerTest.sendClick(id), targetId); return Object.assign({ targetId }, result); } async function expectStoredClick(click) { expect(click.sent).toBe(true); - const events = await findClickEvents(process.env.UNOMI_READ_CREDENTIALS, click.targetId); - expect(events).toHaveLength(1); + const clickEvents = await events(click.targetId); + expect(clickEvents).toHaveLength(1); } test.describe(server.name, () => { - test('the browser build runs without a Buffer polyfill', async ({ page }) => { + test('the browser build runs without a Buffer polyfill (UNOMI-1023)', async ({ page }) => { const errors = []; page.on('pageerror', error => errors.push(error.message)); const { context } = await openPage(page, LISTED_ORIGIN, siteConfig); @@ -62,20 +112,19 @@ test.describe(server.name, () => { expect(context.loaded).toBe(true); }); - test('collects events from a page with empty "attributes", as the Unomi manual showed', async ({ page }) => { + test('collects events from a page with empty "attributes", as the Unomi manual showed (UNOMI-1024)', async ({ page }) => { const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ pageAttributes: '{}' }, siteConfig)); expect(context.loaded).toBe(true); await expectStoredClick(await sendClick(page, 'empty-page-attributes')); }); - test('sends non-empty page "attributes" as before', async ({ page }) => { + test('sends non-empty page "attributes" as before (UNOMI-1024)', async ({ page }) => { // No default page schema accepts attributes with content, so the server drops the event, as with // 1.5.0 (compare-1.5.0 checks that the request is the same). Unomi 2.0 to 2.3 accept an empty one. await openPage(page, LISTED_ORIGIN, Object.assign({ pageAttributes: '{"color":"blue"}' }, siteConfig)); const click = await sendClick(page, 'page-attributes'); expect(click.sent).toBe(true); - const events = await findClickEvents(process.env.UNOMI_READ_CREDENTIALS, click.targetId, 5000); - expect(events).toHaveLength(0); + expect(await events(click.targetId, { timeoutMs: 5000 })).toHaveLength(0); }); test('loads the context and collects an event with the site configuration', async ({ page }) => { @@ -101,4 +150,374 @@ test.describe(server.name, () => { expect(context.loaded).toBe(true); }); + + test('works when the configuration has no timeoutInMilliseconds (UNOMI-1043)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ timeout: 'none' }, siteConfig)); + expect(context.loaded).toBe(true); + await expectStoredClick(await sendClick(page, 'no-timeout')); + }); + + test('shows the personalized variant that Unomi chooses', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ personalization: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + expect(await page.evaluate(() => window.trackerTest.shownVariants())).toEqual(['variant-always']); + }); + + test('shows the fallback variant when Unomi cannot be reached', async ({ page }) => { + await page.route(UNOMI_URL + '/**', route => route.abort('connectionrefused')); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ personalization: 'true' }, siteConfig)); + expect(context.loaded).toBe(false); + expect(await page.evaluate(() => window.trackerTest.shownVariants())).toEqual(['variant-fallback']); + }); + + test('shows the fallback variant when Unomi does not answer in time', async ({ page }) => { + // The requests are never answered: the tracker gives up after timeoutInMilliseconds (1s + // here, instead of the page's 10s), so the fallback must come well before 10s + await page.route(UNOMI_URL + '/**', () => {}); + const start = Date.now(); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ personalization: 'true', timeout: '1000' }, siteConfig)); + expect(Date.now() - start).toBeLessThan(5000); + expect(context.loaded).toBe(false); + expect(await page.evaluate(() => window.trackerTest.shownVariants())).toEqual(['variant-fallback']); + }); + + // Clicks on a button do not leave the page; clicks on a link to #arrived do, as far as the tracker + // can tell (it holds them back), but keep the page open, so that the test can go on + const CLICKED = [ + { name: 'a button', config: {} }, + { name: 'a link', config: { clickLink: 'hash' } } + ]; + const SENT = [ + { name: 'as an event listener', config: {} }, + { name: 'with callbacks', config: { clickCallback: 'true' } } + ]; + + for (const clicked of CLICKED) { + for (const sent of SENT) { + test('tracks every click on ' + clicked.name + ' sent with sendClickEvent ' + sent.name + ' (UNOMI-1037)', async ({ page }) => { + const elementId = uniqueId('tracked-element'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId }, clicked.config, sent.config, siteConfig)); + expect(context.loaded).toBe(true); + for (const count of [1, 2, 3]) { + await page.click('#' + elementId); + expect(await events(elementId, { minCount: count })).toHaveLength(count); + } + await expectNoMoreEvents(elementId, 3); + if (sent.config.clickCallback) { + expect(await page.evaluate(() => window.trackerTest.clickCallbacks())).toEqual({ success: 3, error: 0 }); + } else if (clicked.config.clickLink) { + // The click dispatched again follows the link + expect(new URL(page.url()).hash).toBe('#arrived'); + } + }); + } + } + + test('runs the site\'s own click handler once per click on a button sent with sendClickEvent (UNOMI-1046)', async ({ page }) => { + const elementId = uniqueId('tracked-button'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId }, siteConfig)); + expect(context.loaded).toBe(true); + for (const count of [1, 2]) { + await page.click('#' + elementId); + expect(await events(elementId, { minCount: count })).toHaveLength(count); + expect(await page.evaluate(() => window.trackerTest.siteClicks())).toBe(count); + } + }); + + test('lets a single-page application router handle a tracked link, without reloading the page (UNOMI-1046)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true', router: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + const pageLoadId = await page.evaluate(() => window.trackerTest.pageLoadId()); + for (const count of [1, 2]) { + await page.click('#' + elementId); + expect(await events(elementId, { minCount: count })).toHaveLength(count); + await expect.poll(() => page.evaluate(() => window.trackerTest.routed())).toBe(count); + } + expect(new URL(page.url()).pathname).toBe('/arrived'); + expect(await page.evaluate(() => window.trackerTest.pageLoadId())).toBe(pageLoadId); + }); + + for (const sent of SENT) { + test('tracks a second click made before the first event is sent, ' + sent.name + ' (UNOMI-1037)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'hash' }, sent.config, siteConfig)); + expect(context.loaded).toBe(true); + // Unomi does not answer until both clicks are made + const held = await holdEvents(page); + await page.click('#' + elementId); + await page.click('#' + elementId); + await expect.poll(() => held.pending.length).toBe(2); + held.answer(); + expect(await events(elementId, { minCount: 2 })).toHaveLength(2); + await expectNoMoreEvents(elementId, 2); + if (sent.config.clickCallback) { + expect(await page.evaluate(() => window.trackerTest.clickCallbacks())).toEqual({ success: 2, error: 0 }); + } + }); + } + + for (const clicked of CLICKED) { + test('calls the error callback on each click on ' + clicked.name + ' when the event cannot be sent (UNOMI-1037)', async ({ page }) => { + const elementId = uniqueId('tracked-element'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickCallback: 'true' }, clicked.config, siteConfig)); + expect(context.loaded).toBe(true); + await page.route(UNOMI_URL + '/eventcollector', route => route.abort('connectionrefused')); + for (const count of [1, 2, 3]) { + await page.click('#' + elementId); + await expect.poll(() => page.evaluate(() => window.trackerTest.clickCallbacks().error)).toBe(count); + } + expect(await page.evaluate(() => window.trackerTest.clickCallbacks())).toEqual({ success: 0, error: 3 }); + }); + } + + test('follows a tracked link when its event cannot be sent (UNOMI-1037)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.route(UNOMI_URL + '/eventcollector', route => route.abort('connectionrefused')); + await page.click('#' + elementId); + await page.waitForURL('**/arrived', { timeout: 5000 }); + }); + + test('follows a tracked link at once when Unomi could not be reached (UNOMI-1040)', async ({ page }) => { + await page.route(UNOMI_URL + '/**', route => route.abort('connectionrefused')); + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true' }, siteConfig)); + expect(context.loaded).toBe(false); + await page.click('#' + elementId); + await page.waitForURL('**/arrived', { timeout: 3000 }); + }); + + test('follows a tracked link at once when tracking is turned off (UNOMI-1040)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context, requests } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.evaluate(() => window.trackerTest.disableTracking()); + const sentBefore = requests.length; + await page.click('#' + elementId); + await page.waitForURL('**/arrived', { timeout: 3000 }); + expect(requests.slice(sentBefore).map(request => request.url())).toEqual([]); + }); + + test('opens a tracked link in a new tab with Ctrl or Cmd, and still tracks the click (UNOMI-1041)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + const newTab = page.context().waitForEvent('page'); + await page.click('#' + elementId, { modifiers: ['ControlOrMeta'] }); + await newTab; + expect(new URL(page.url()).pathname).toBe('/'); + expect(await events(elementId)).toHaveLength(1); + await expectNoMoreEvents(elementId, 1); + }); + + for (const child of [{ name: 'without', config: { clickChild: 'plain' } }, { name: 'with', config: { clickChild: 'withId' } }]) { + test('tracks a click on a child, ' + child.name + ' its own id, of a tracked link, and follows the link (UNOMI-1047)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true' }, child.config, siteConfig)); + expect(context.loaded).toBe(true); + // Until Unomi answers, the link is not followed + const held = await holdEvents(page); + await page.click('#' + elementId + ' .tracked-child'); + await expect.poll(() => held.pending.length).toBe(1); + await page.waitForTimeout(500); + expect(new URL(page.url()).pathname).toBe('/'); + held.answer(); + await page.waitForURL('**/arrived', { timeout: 5000 }); + expect(await events(elementId)).toHaveLength(1); + if (child.config.clickChild === 'withId') { + expect(await events(elementId + '-child', { timeoutMs: 2000 })).toHaveLength(0); + } + }); + + test('tracks a click on a child, ' + child.name + ' its own id, of a tracked button, once (UNOMI-1047)', async ({ page }) => { + const elementId = uniqueId('tracked-button'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId }, child.config, siteConfig)); + expect(context.loaded).toBe(true); + await page.click('#' + elementId + ' .tracked-child'); + expect(await events(elementId)).toHaveLength(1); + await expectNoMoreEvents(elementId, 1); + expect(await page.evaluate(() => window.trackerTest.siteClicks())).toBe(1); + }); + } + + test('lets a router on the link itself handle a tracked link, once per click (UNOMI-1040, UNOMI-1046)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'true', router: 'link' }, siteConfig)); + expect(context.loaded).toBe(true); + const pageLoadId = await page.evaluate(() => window.trackerTest.pageLoadId()); + for (const count of [1, 2]) { + await page.click('#' + elementId); + expect(await events(elementId, { minCount: count })).toHaveLength(count); + await page.waitForTimeout(500); + expect(await page.evaluate(() => window.trackerTest.routed())).toBe(count); + } + expect(await page.evaluate(() => window.trackerTest.pageLoadId())).toBe(pageLoadId); + }); + + test('opens a tracked link to a new tab at once, without waiting for Unomi (UNOMI-1040)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'blank' }, siteConfig)); + expect(context.loaded).toBe(true); + const held = await holdEvents(page); + const newTab = page.context().waitForEvent('page', { timeout: 3000 }); + await page.click('#' + elementId); + await newTab; + expect(held.pending.length).toBe(1); + held.answer(); + expect(await events(elementId)).toHaveLength(1); + }); + + test('downloads from a tracked link at once, without waiting for Unomi (UNOMI-1040)', async ({ page }) => { + const elementId = uniqueId('tracked-link'); + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ clickButton: elementId, clickLink: 'download' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.route(LISTED_ORIGIN + '/arrived', route => route.fulfill({ status: 200, contentType: 'text/plain', body: 'arrived' })); + const held = await holdEvents(page); + const download = page.waitForEvent('download', { timeout: 3000 }); + await page.click('#' + elementId); + await download; + held.answer(); + expect(await events(elementId)).toHaveLength(1); + }); + + for (const form of [{ name: 'a link', config: { clickButton: 'L', clickLink: 'true' } }, { name: 'a form', config: { form: FORM_NAME, formSubmit: 'native' } }]) { + test('lets ' + form.name + ' go on at once when its event cannot even be sent (UNOMI-1040)', async ({ page }) => { + const config = Object.assign({}, form.config); + if (config.clickButton) { + config.clickButton = uniqueId('tracked-link'); + } + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign(config, siteConfig)); + expect(context.loaded).toBe(true); + await page.evaluate(() => window.trackerTest.breakServerUrl()); + await page.click(config.clickButton ? '#' + config.clickButton : '#submit-form'); + await page.waitForURL(config.clickButton ? '**/arrived' : '**/submitted?**', { timeout: 3000 }); + }); + + test('lets ' + form.name + ' go on after 1.5s at most when Unomi never answers and there is no timeout (UNOMI-1040)', async ({ page }) => { + const config = Object.assign({ timeout: '-1' }, form.config); + if (config.clickButton) { + config.clickButton = uniqueId('tracked-link'); + } + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign(config, siteConfig)); + expect(context.loaded).toBe(true); + await page.route(UNOMI_URL + '/eventcollector', () => {}); + const start = Date.now(); + await page.click(config.clickButton ? '#' + config.clickButton : '#submit-form'); + await page.waitForURL(config.clickButton ? '**/arrived' : '**/submitted?**', { timeout: 5000 }); + expect(Date.now() - start).toBeGreaterThanOrEqual(1400); + }); + } + + test('sends the submit of a form that Unomi tracks, then lets the site handle it (UNOMI-1042)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME }, siteConfig)); + expect(context.loaded).toBe(true); + expect(await page.evaluate(() => window.trackerTest.watchedForms())).toContain(FORM_NAME); + // Until Unomi answers, the site does not see the submit + const held = await holdEvents(page); + await page.click('#submit-form'); + await expect.poll(() => held.pending.length).toBe(1); + await page.waitForTimeout(500); + expect(await page.evaluate(() => window.trackerTest.siteSubmits())).toEqual([]); + held.answer(); + const formEvents = await events(FORM_NAME, { matching: thisSession(context) }); + expect(formEvents).toHaveLength(1); + expect(formEvents[0].eventType).toBe('form'); + // Each kind of field: the checked checkboxes and the selected options as lists, the checked + // radio button, the text area; the empty field is left out + expect(formEvents[0].flattenedProperties.fields).toEqual({ + email: '[email protected]', + topics: ['news'], + country: 'ch', + languages: ['fr', 'de'], + contact: 'email', + message: 'Hello' + }); + // Then the site gets the submit once (not also the visitor's own), which says which button was used + await expect.poll(() => page.evaluate(() => window.trackerTest.siteSubmits().length)).toBe(1); + await page.waitForTimeout(1000); + expect(await page.evaluate(() => window.trackerTest.siteSubmits())).toEqual([{ submitter: 'submit-form' }]); + await expectNoMoreEvents(FORM_NAME, 1, { matching: thisSession(context) }); + }); + + // Browsers with HTMLFormElement.requestSubmit, and older ones, where the tracker submits the form itself + const BROWSERS = [ + { name: '', config: {} }, + { name: ', in a browser without requestSubmit', config: { oldBrowser: 'true' } } + ]; + const BUTTONS = [ + { name: 'the button that was used', id: 'delete-form', expected: { action: ['delete'] } }, + { name: 'a button named "submit"', id: 'submit-named', expected: { submit: ['go'] } }, + { name: 'an image button', id: 'submit-image', expected: { 'pic.x': [/^\d+$/], 'pic.y': [/^\d+$/] } }, + { name: 'a button the site removes meanwhile', id: 'submit-removed', expected: { action: ['removed'] } } + ]; + + for (const browser of BROWSERS) { + for (const button of BUTTONS) { + test('submits a tracked form with ' + button.name + ', as a native submit does' + browser.name + ' (UNOMI-1042)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native' }, browser.config, siteConfig)); + expect(context.loaded).toBe(true); + await page.click('#' + button.id); + await page.waitForURL('**/submitted?**', { timeout: 5000 }); + expectSubmitted(page, button.expected); + expect(await events(FORM_NAME, { matching: thisSession(context) })).toHaveLength(1); + await expectNoMoreEvents(FORM_NAME, 1, { matching: thisSession(context) }); + }); + } + + test('submits a tracked form with its button when the event cannot be sent' + browser.name + ' (UNOMI-1042)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native' }, browser.config, siteConfig)); + expect(context.loaded).toBe(true); + await page.route(UNOMI_URL + '/eventcollector', route => route.abort('connectionrefused')); + await page.click('#delete-form'); + await page.waitForURL('**/submitted?**', { timeout: 5000 }); + expectSubmitted(page, { action: ['delete'] }); + }); + } + + test('submits a tracked form into a new tab at once, without waiting for Unomi (UNOMI-1040)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native', formTarget: '_blank' }, siteConfig)); + expect(context.loaded).toBe(true); + const held = await holdEvents(page); + const newTab = page.context().waitForEvent('page', { timeout: 3000 }); + await page.click('#delete-form'); + const tab = await newTab; + await tab.waitForURL('**/submitted?**', { timeout: 3000 }); + expect(new URL(tab.url()).searchParams.getAll('action')).toEqual(['delete']); + held.answer(); + expect(await events(FORM_NAME, { matching: thisSession(context) })).toHaveLength(1); + }); + + test('submits a tracked form with Enter, as a native submit does (UNOMI-1042)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.focus('input[name="email"]'); + await page.keyboard.press('Enter'); + await page.waitForURL('**/submitted?**', { timeout: 5000 }); + // Enter submits with the form's first submit button + expectSubmitted(page, { action: ['send'] }); + expect(await events(FORM_NAME, { matching: thisSession(context) })).toHaveLength(1); + }); + + test('tracks a click on a submit button of a tracked form, and its submit (UNOMI-1037, UNOMI-1042)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native', trackSubmitButton: 'true' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.click('#delete-form'); + await page.waitForURL('**/submitted?**', { timeout: 5000 }); + expectSubmitted(page, { action: ['delete'] }); + expect(await events('delete-form', { matching: thisSession(context) })).toHaveLength(1); + expect(await events(FORM_NAME, { matching: thisSession(context) })).toHaveLength(1); + await expectNoMoreEvents('delete-form', 1, { matching: thisSession(context) }); + await expectNoMoreEvents(FORM_NAME, 1, { matching: thisSession(context) }); + }); + + test('submits a tracked form at once when tracking is turned off (UNOMI-1040)', async ({ page }) => { + const { context } = await openPage(page, LISTED_ORIGIN, Object.assign({ form: FORM_NAME, formSubmit: 'native' }, siteConfig)); + expect(context.loaded).toBe(true); + await page.evaluate(() => window.trackerTest.disableTracking()); + await page.click('#submit-form'); + await page.waitForURL('**/submitted?**', { timeout: 3000 }); + expectSubmitted(page, { action: ['send'] }); + }); }); diff --git a/test/servers/unomi.js b/test/servers/unomi.js index bea6a2b..83c3fb6 100644 --- a/test/servers/unomi.js +++ b/test/servers/unomi.js @@ -100,6 +100,48 @@ async function retry(action, timeoutMs = 120000) { } } +// The endpoints the tests use answer. A starting server registers its endpoints one by one, and can +// remove and add them again while it starts, so a single answer is not enough. The event collector +// refuses an empty list of events (400), which shows it is there without storing anything. +async function endpointsAnswer(credentials) { + const probe = { sessionId: 'tracker-test-probe', events: [] }; + const post = (path, body, headers) => fetch(UNOMI_URL + path, { + method: 'POST', + headers: Object.assign({ 'Content-Type': 'application/json' }, headers), + body: JSON.stringify(body) + }); + const context = await post('/cxs/context.json', probe); + const collector = await post('/cxs/eventcollector', probe); + const search = await post('/cxs/events/search', { limit: 1 }, { Authorization: basic(credentials) }); + return context.status === 200 && (collector.status === 200 || collector.status === 400) && search.status === 200; +} + +// Waits until the server has kept answering for a while: STABLE_ROUNDS checks in a row, 2s apart. +const STABLE_ROUNDS = 5; +async function waitUntilStable(credentials, timeoutMs = 180000) { + const deadline = Date.now() + timeoutMs; + let rounds = 0; + let lastProblem = 'no check yet'; + while (rounds < STABLE_ROUNDS) { + let ok = false; + try { + if (await endpointsAnswer(credentials)) { + ok = true; + } else { + lastProblem = 'an endpoint did not answer as expected'; + } + } catch (e) { + // not answering yet + lastProblem = String(e); + } + rounds = ok ? rounds + 1 : 0; + if (Date.now() > deadline) { + throw new Error('Unomi did not answer steadily at ' + UNOMI_URL + ' within ' + timeoutMs / 1000 + 's (last problem: ' + lastProblem + ')'); + } + await sleep(2000); + } +} + // Creates the scope if it is missing, and waits until the server returns it. async function ensureScope(credentials) { await retry(async () => { @@ -118,34 +160,65 @@ async function ensureScope(credentials) { }); } -// Prepares the server before the tests: the scope that the tracker events use. -// Returns the credentials that can read the events. +// A rule on the submits of the test form. Unomi returns its condition to the tracker in the +// "tracked conditions" of the context, which is how the tracker knows which forms to watch. +const FORM_NAME = 'tracker-test-form'; +async function ensureFormRule(credentials) { + await request('POST', '/cxs/rules', { + credentials: credentials, + body: { + metadata: { id: 'tracker-test-form-rule', name: 'Tracker test form', scope: SCOPE, enabled: true }, + condition: { type: 'formEventCondition', parameterValues: { formId: FORM_NAME } }, + actions: [{ type: 'setPropertyAction', parameterValues: { setPropertyName: 'properties.trackerTestForm', setPropertyValue: 'sent', setPropertyStrategy: 'alwaysSet' } }] + } + }); + // Rules are loaded in the background: wait until the context returns the condition + await retry(async () => { + const context = await request('POST', '/cxs/context.json', { + body: { sessionId: 'tracker-test-probe', source: { scope: SCOPE, itemType: 'page', itemId: 'tracker-test-page' } } + }); + const tracked = (context.trackedConditions || []).some(condition => condition.parameterValues && condition.parameterValues.formId === FORM_NAME); + if (!tracked) { + throw new Error('The form rule is not in the tracked conditions yet'); + } + }); +} + +// Prepares the server before the tests: the scope that the tracker events use, and the rule that +// makes the tracker watch the test form. Returns the credentials that can read the events. async function setUp(t) { await waitForServer(); await ensureScope(t.admin); + await waitUntilStable(t.admin); + await ensureFormRule(t.admin); console.log('Server ready: ' + t.name + ', scope ' + SCOPE); return { credentials: t.admin }; } -// Polls until click events on the given target are indexed, and returns them. -async function findClickEvents(credentials, targetId, timeoutMs = 15000) { +// Polls until at least minCount events on the given target are indexed, and returns them, newest +// first. Only the 10 newest events on the target are read; with "matching", only those it accepts +// count and are returned (a server kept from an earlier run can hold events on the same target). +// After timeoutMs it returns what it found, which can be fewer than minCount. +async function findEvents(credentials, targetId, { timeoutMs = 15000, minCount = 1, matching = () => true } = {}) { const deadline = Date.now() + timeoutMs; for (;;) { const result = await request('POST', '/cxs/events/search', { credentials: credentials, body: { limit: 10, + sortby: 'timeStamp:desc', condition: { type: 'eventPropertyCondition', parameterValues: { propertyName: 'target.itemId', comparisonOperator: 'equals', propertyValue: targetId } } } }); - if ((result.list && result.list.length > 0) || Date.now() > deadline) { - return result.list || []; + const events = (result.list || []).filter(matching); + if (events.length >= minCount || Date.now() > deadline) { + return events; } await sleep(1000); } } -module.exports = { UNOMI_URL, TARGETS, target, setUp, findClickEvents }; +module.exports = { UNOMI_URL, TARGETS, FORM_NAME, target, setUp, findEvents }; diff --git a/test/spec.js b/test/spec.js index d28dd4b..3037d34 100644 --- a/test/spec.js +++ b/test/spec.js @@ -23,7 +23,7 @@ assert(tracker !== null); globalThis.document = { cookie: 'wem-session-id=test-session' }; -// Crawler detection: the same result with and without Node's Buffer +// UNOMI-1023: crawler detection, the same result with and without Node's Buffer const crawlerTracker = unomi.useTracker(); const edgeStrings = ['', 'abc', 'é漢字😀', '\uD800', 'a\uDC00b', '😀\uD800', 'x'.repeat(4096), 'é'.repeat(2048), 'é'.repeat(2049)]; for (let i = 0; i < 500; i++) { @@ -57,7 +57,7 @@ try { globalThis.Buffer = nodeBuffer; } -// Page properties sent with events: an empty "attributes" is left out, digitalData.page is unchanged +// UNOMI-1024: page properties sent with events: an empty "attributes" is left out, digitalData.page is unchanged function pagePropertiesFor(attributes) { const page = { pageInfo: { pageID: 'home', pageName: 'Home' }, consentTypes: [] }; if (attributes !== undefined) { @@ -82,4 +82,251 @@ assert.deepStrictEqual(Object.keys(pageResult.target), ['pageInfo', 'consentType assert.strictEqual(pageResult.source.pageInfo, pageResult.page.pageInfo, 'pageInfo is the same object'); assert.deepStrictEqual(pageResult.page.attributes, {}, 'digitalData.page keeps its attributes'); -console.log('Tests passed'); \ No newline at end of file +// UNOMI-1043: without a usable timeoutInMilliseconds, the tracker uses its default instead of a timer +// that fires at once +function timeoutFor(timeoutInMilliseconds) { + const t = unomi.useTracker(); + const wemInitConfig = { contextServerUrl: '' }; + if (timeoutInMilliseconds !== 'missing') { + wemInitConfig.timeoutInMilliseconds = timeoutInMilliseconds; + } + t.initTracker({ wemInitConfig }); + return t.timeoutInMilliseconds; +} +assert.strictEqual(timeoutFor('missing'), 1500, 'no timeout: the default'); +for (const value of [undefined, null, '', ' ', 'soon', NaN, Infinity, 0, -5, '0']) { + assert.strictEqual(timeoutFor(value), 1500, 'the default for ' + JSON.stringify(String(value))); +} +assert.strictEqual(timeoutFor(3000), 3000, 'a configured timeout is kept'); +assert.strictEqual(timeoutFor(-1), -1, '-1 (no timeout) is kept'); +assert.strictEqual(timeoutFor('3000'), 3000, 'a number given as a string, as from an HTML attribute, is used'); +assert.strictEqual(timeoutFor('-1'), -1, '-1 given as a string is kept'); + +// UNOMI-1037, UNOMI-1040, UNOMI-1041, UNOMI-1046, UNOMI-1047: sendClickEvent, what happens to the +// visitor's click. Fake elements have attributes and a parent; click() runs the tracker's listener on +// the tracked element as a browser does (currentTarget is the tracked element, target the clicked +// one). collectEvent is replaced, so each test sends or fails the event itself. +function fakeElement(localName, attributes = {}, properties = {}) { + const element = Object.assign({ + localName, + parentElement: null, + getAttribute: name => Object.prototype.hasOwnProperty.call(attributes, name) ? attributes[name] : null, + hasAttribute: name => Object.prototype.hasOwnProperty.call(attributes, name) + }, properties); + if (attributes.id) { + element.id = attributes.id; + } + return element; +} + +const FORM = fakeElement('form'); +const ELEMENTS = { + // Clicks that leave the page + link: () => fakeElement('a', { href: '/next' }), + linkToTop: () => fakeElement('a', { href: '/next', target: '_top' }), + area: () => fakeElement('area', { href: '/next' }), + submitButton: () => fakeElement('button', {}, { type: 'submit', form: FORM }), + submitInput: () => fakeElement('input', {}, { type: 'submit', form: FORM }), + imageInput: () => fakeElement('input', {}, { type: 'image', form: FORM }), + // Clicks that do not + linkWithoutAddress: () => fakeElement('a'), + linkToFragment: () => fakeElement('a', { href: '#part' }), + linkToScript: () => fakeElement('a', { href: 'javascript:void(0)' }), + linkToNewTab: () => fakeElement('a', { href: '/next', target: '_blank' }), + download: () => fakeElement('a', { href: '/file.pdf', download: '' }), + submitButtonToNewTab: () => fakeElement('button', { formtarget: '_blank' }, { type: 'submit', form: FORM }), + button: () => fakeElement('button', {}, { type: 'button', form: FORM }), + submitButtonWithoutForm: () => fakeElement('button', {}, { type: 'submit', form: null }), + checkbox: () => fakeElement('input', {}, { type: 'checkbox', form: FORM }), + div: () => fakeElement('div') +}; +const LEAVING = ['link', 'linkToTop', 'area', 'submitButton', 'submitInput', 'imageInput']; + +function clickTracker(kind = 'link', { fallback = false, timeout = 10000 } = {}) { + const t = unomi.useTracker(); + t.initTracker({ scope: 'test', site: { siteInfo: { siteID: 'test' } }, page: { pageInfo: { pageID: 'home', pageName: 'Home' }, consentTypes: [] }, events: [], wemInitConfig: { contextServerUrl: '', timeoutInMilliseconds: timeout } }); + t.fallback = fallback; + const sent = []; + t.collectEvent = (event, success, error) => sent.push({ event, success, error }); + const element = ELEMENTS[kind](); + element.id = 'element'; + element.dispatchedAgain = []; + element.click = () => { + const event = clickOn(element); + t.sendClickEvent(event); + element.dispatchedAgain.push(event); + }; + return { t, sent, element }; +} + +// A click on clicked, seen by the tracker's listener on listening (the clicked element by default) +function clickOn(clicked, keys = {}, listening = clicked) { + const event = { + target: clicked, + currentTarget: listening, + defaultPrevented: false, + preventDefault() { + event.defaultPrevented = true; + } + }; + return Object.assign(event, keys); +} + +let clicks; +let click; +for (const kind of Object.keys(ELEMENTS)) { + const leaves = LEAVING.includes(kind); + for (const outcome of ['success', 'error']) { + clicks = clickTracker(kind); + click = clickOn(clicks.element); + clicks.t.sendClickEvent(click); + assert.strictEqual(click.defaultPrevented, leaves, kind + ': the click is ' + (leaves ? '' : 'not ') + 'held back while its event is sent'); + assert.strictEqual(clicks.sent.length, 1, kind + ': one event is sent'); + assert.strictEqual(clicks.sent[0].event.target.itemId, 'element', kind + ': the event is on the element'); + clicks.sent[0][outcome]({}); + assert.strictEqual(clicks.element.dispatchedAgain.length, leaves ? 1 : 0, kind + ', ' + outcome + ': the click is ' + (leaves ? '' : 'not ') + 'dispatched again'); + if (leaves) { + assert.strictEqual(clicks.element.dispatchedAgain[0].defaultPrevented, false, kind + ': the click dispatched again goes through'); + } + assert.strictEqual(clicks.sent.length, 1, kind + ': the click dispatched again is not sent'); + assert.deepStrictEqual(clicks.t.eventsPrevented, [], kind + ': nothing is left marked'); + clicks.sent[0][outcome === 'success' ? 'error' : 'success']({}); + assert.strictEqual(clicks.element.dispatchedAgain.length, leaves ? 1 : 0, kind + ': a second outcome for the same click does nothing'); + clicks.t.sendClickEvent(clickOn(clicks.element)); + assert.strictEqual(clicks.sent.length, 2, kind + ': the next click is sent too'); + } +} + +// An image, an icon or some text inside the tracked link or button (UNOMI-1047) +for (const childId of [undefined, 'icon']) { + for (const kind of ['link', 'submitButton', 'button']) { + clicks = clickTracker(kind); + const child = fakeElement('img', childId ? { id: childId } : {}); + child.parentElement = clicks.element; + child.dispatchedAgain = 0; + child.click = () => { + child.dispatchedAgain++; + clicks.t.sendClickEvent(clickOn(child, {}, clicks.element)); + }; + click = clickOn(child, {}, clicks.element); + clicks.t.sendClickEvent(click); + const leaves = kind !== 'button'; + const label = kind + ' with a child ' + (childId ? 'with' : 'without') + ' an id'; + assert.strictEqual(clicks.sent.length, 1, label + ': the click is sent'); + assert.strictEqual(clicks.sent[0].event.target.itemId, 'element', label + ': on the tracked element'); + assert.strictEqual(click.defaultPrevented, leaves, label + ': held back as for the element itself'); + clicks.sent[0].success({}); + assert.strictEqual(child.dispatchedAgain, leaves ? 1 : 0, label + ': dispatched again on the clicked child'); + assert.strictEqual(clicks.sent.length, 1, label + ': the click dispatched again is not sent'); + } +} + +// Called from a listener on the document: the clicked element is tracked, as before +clicks = clickTracker(); +click = clickOn(clicks.element, {}, { nodeType: 9 }); +clicks.t.sendClickEvent(click); +assert.strictEqual(clicks.sent.length, 1, 'from a listener on the document, the click is sent'); +assert.strictEqual(clicks.sent[0].event.target.itemId, 'element', 'on the clicked element'); +assert.strictEqual(click.defaultPrevented, true, 'and held back'); + +// A click the site already prevented (a router on the link, registered first) is the site's +clicks = clickTracker(); +click = clickOn(clicks.element, { defaultPrevented: true }); +clicks.t.sendClickEvent(click); +assert.strictEqual(clicks.sent.length, 1, 'a click the site prevented is sent'); +clicks.sent[0].success({}); +assert.strictEqual(clicks.element.dispatchedAgain.length, 0, 'and not dispatched again'); + +clicks = clickTracker(); +clicks.t.sendClickEvent(clickOn(clicks.element)); +clicks.t.sendClickEvent(clickOn(clicks.element)); +assert.strictEqual(clicks.sent.length, 2, 'a second click before the first event is sent is sent too'); +clicks.sent[0].success({}); +clicks.sent[1].success({}); +assert.deepStrictEqual(clicks.element.dispatchedAgain.map(event => event.defaultPrevented), [false, false], 'each click is dispatched again once'); + +for (const kind of ['link', 'button']) { + const callbacks = []; + clicks = clickTracker(kind); + for (const outcome of ['success', 'error', 'success']) { + click = clickOn(clicks.element); + clicks.t.sendClickEvent(click, () => callbacks.push('success'), () => callbacks.push('error')); + assert.strictEqual(click.defaultPrevented, kind === 'link', kind + ' with callbacks: held back only if the click leaves the page'); + clicks.sent[clicks.sent.length - 1][outcome]({}); + } + assert.strictEqual(clicks.sent.length, 3, kind + ' with callbacks: every click is sent'); + assert.deepStrictEqual(callbacks, ['success', 'error', 'success'], kind + ' with callbacks: the callback of each outcome is called'); + assert.strictEqual(clicks.element.dispatchedAgain.length, 0, kind + ' with callbacks: the site handles the click itself'); +} + +for (const kind of ['link', 'button']) { + clicks = clickTracker(kind, { fallback: true }); + click = clickOn(clicks.element); + clicks.t.sendClickEvent(click); + assert.strictEqual(click.defaultPrevented, false, kind + ' in fallback: the click goes through'); + assert.strictEqual(clicks.sent.length, 0, kind + ' in fallback: nothing is sent'); +} + +for (const key of ['metaKey', 'ctrlKey', 'shiftKey', 'altKey']) { + clicks = clickTracker(); + click = clickOn(clicks.element, { [key]: true }); + clicks.t.sendClickEvent(click); + assert.strictEqual(click.defaultPrevented, false, 'a click with ' + key + ' goes through (new tab or window)'); + assert.strictEqual(clicks.sent.length, 1, 'a click with ' + key + ' is sent'); + clicks.sent[0].success({}); + assert.strictEqual(clicks.element.dispatchedAgain.length, 0, 'and is not dispatched again'); + click = clickOn(clicks.element, { [key]: true }); + clicks.t.sendClickEvent(click, () => {}); + assert.strictEqual(click.defaultPrevented, true, 'with a callback, a click with ' + key + ' is held back for the site'); +} + +// When sending the event throws at once, the click goes on, or the error callback is called +clicks = clickTracker(); +clicks.t.collectEvent = () => { + throw new Error('cannot send'); +}; +click = clickOn(clicks.element); +clicks.t.sendClickEvent(click); +assert.strictEqual(click.defaultPrevented, true, 'when sending throws, the click was held back'); +assert.strictEqual(clicks.element.dispatchedAgain.length, 0, 'not dispatched again during the visitor\'s click'); +let thrownErrors = 0; +clicks.t.sendClickEvent(clickOn(clicks.element), () => {}, () => thrownErrors++); +const throwing = clicks; +setTimeout(() => { + assert.strictEqual(throwing.element.dispatchedAgain.length, 1, 'dispatched again right after it'); + assert.strictEqual(thrownErrors, 1, 'with callbacks, the error callback is called'); +}, 0); + +clicks = clickTracker(); +click = clickOn(fakeElement('a', { href: '/next' })); +clicks.t.sendClickEvent(click); +assert.strictEqual(click.defaultPrevented, false, 'an element without id or name is not tracked'); +assert.strictEqual(clicks.sent.length, 0, 'and nothing is sent'); + +// Without a request timeout (-1), a held back click goes on after 1.5s at most, once +const noAnswer = clickTracker('link', { timeout: -1 }); +noAnswer.t.sendClickEvent(clickOn(noAnswer.element)); +assert.strictEqual(noAnswer.element.dispatchedAgain.length, 0, 'without a timeout, the click is held back at first'); +setTimeout(() => { + assert.strictEqual(noAnswer.element.dispatchedAgain.length, 0, 'still held back after 1s'); +}, 1000); +setTimeout(() => { + assert.strictEqual(noAnswer.element.dispatchedAgain.length, 1, 'dispatched again after 1.5s'); + noAnswer.sent[0].success({}); + assert.strictEqual(noAnswer.element.dispatchedAgain.length, 1, 'a late answer from Unomi does not dispatch it again'); + // The last check, which runs after all the others + console.log('Tests passed'); +}, 1700); + +// UNOMI-1038: ids of tracked videos and links, mapped through digitalData.sourceLocalIdentifierMap +function resolveId(id, sourceLocalIdentifierMap) { + const t = unomi.useTracker(); + t.initTracker({ sourceLocalIdentifierMap: sourceLocalIdentifierMap, wemInitConfig: { contextServerUrl: '', timeoutInMilliseconds: -1 } }); + return t._resolveId(id); +} + +const idMap = { 'live-': 'default-' }; +assert.strictEqual(resolveId('live-video', idMap), 'default-video', 'a mapped part at the start of the id'); +assert.strictEqual(resolveId('page-live-video', idMap), 'page-default-video', 'a mapped part inside the id'); +assert.strictEqual(resolveId('other-video', idMap), 'other-video', 'an id without a mapped part is unchanged'); +assert.strictEqual(resolveId('live-video', undefined), 'live-video', 'no map, no change');
