// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
import React from 'react';
import test from 'tape';
import {mountWithTheme} from 'test/helpers/component-utils';
import {renderBasemapAttribution, dedupeBasemapAttributions} from '@kepler.gl/components';
// Helper: mount the parsed nodes and return the enzyme wrapper.
function mountAttribution(html) {
return mountWithTheme(
{renderBasemapAttribution(html, 'k')}
);
}
test('renderBasemapAttribution -> plain text', t => {
const wrapper = mountAttribution('© OpenStreetMap contributors');
t.equal(wrapper.find('a').length, 0, 'No anchors for plain text');
t.equal(wrapper.text(), '© OpenStreetMap contributors', 'Text preserved verbatim');
t.end();
});
test('renderBasemapAttribution -> single safe anchor', t => {
const wrapper = mountAttribution('© CARTO ');
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'One anchor rendered');
t.equal(anchors.at(0).prop('href'), 'https://carto.com/attributions', 'href preserved');
t.equal(anchors.at(0).prop('target'), '_blank', 'opens in new tab');
t.equal(anchors.at(0).prop('rel'), 'noopener noreferrer', 'safe rel');
t.equal(anchors.at(0).text(), 'CARTO', 'anchor text preserved');
t.ok(wrapper.text().startsWith('©'), 'leading text preserved');
t.end();
});
test('renderBasemapAttribution -> OpenFreeMap style (multiple links + entities)', t => {
const html =
'OpenFreeMap ' +
'© OpenMapTiles ' +
'Data from OpenStreetMap ';
const wrapper = mountAttribution(html);
const anchors = wrapper.find('a');
t.equal(anchors.length, 3, 'All three links preserved');
t.deepEqual(
anchors.map(a => a.prop('href')),
[
'https://openfreemap.org',
'https://www.openmaptiles.org/',
'https://www.openstreetmap.org/copyright'
],
'All hrefs preserved in order'
);
t.ok(wrapper.text().includes('© OpenMapTiles'), 'HTML entity (©) decoded');
t.end();
});
test('renderBasemapAttribution -> drops unsafe javascript: href, keeps text', t => {
const wrapper = mountAttribution(
// eslint-disable-next-line no-script-url
'Bad and Good '
);
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'Only the safe anchor becomes a link');
t.equal(anchors.at(0).prop('href'), 'https://ok.com', 'safe href kept');
t.ok(wrapper.text().includes('Bad'), 'unsafe link text still rendered as plain text');
const unsafeCount = anchors.reduce(
(n, a) => n + ((a.prop('href') || '').startsWith('javascript:') ? 1 : 0),
0
);
t.equal(unsafeCount, 0, 'no javascript: href rendered');
t.end();
});
test('renderBasemapAttribution -> mailto is allowed', t => {
const wrapper = mountAttribution('Contact ');
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'mailto anchor is a link');
t.equal(anchors.at(0).prop('href'), 'mailto:hi@example.com', 'mailto href preserved');
t.end();
});
test('renderBasemapAttribution -> nested tags and > inside attribute (regex-breaking cases)', t => {
// A '>' inside an attribute value and nested markup would break the old
// regex-based parser; the DOM parser handles both.
const html = 'Bold Link tail';
const wrapper = mountAttribution(html);
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'One anchor despite > inside attribute');
t.equal(anchors.at(0).prop('href'), 'https://x.com', 'href parsed correctly');
t.equal(anchors.at(0).text(), 'Bold Link', 'nested tag content flattened to text');
t.ok(wrapper.text().includes('tail'), 'trailing text preserved');
t.end();
});
test('renderBasemapAttribution -> empty / whitespace', t => {
t.deepEqual(renderBasemapAttribution('', 'k'), [], 'empty string yields no nodes');
const wrapper = mountAttribution(' ');
t.equal(wrapper.find('a').length, 0, 'whitespace yields no anchors');
t.end();
});
test('renderBasemapAttribution -> single space preserved between adjacent links', t => {
// whitespace between two links must collapse to a single space (not be
// dropped), so links don't run together (e.g. OpenFreeMap-style strings)
const html = 'A B ';
const wrapper = mountAttribution(html);
t.equal(wrapper.find('a').length, 2, 'both links rendered');
t.equal(wrapper.text(), 'A B', 'a single separating space is preserved');
t.end();
});
test('renderBasemapAttribution -> collapses whitespace runs but keeps inter-link spacing', t => {
const html =
'OpenFreeMap ' +
'© OpenMapTiles ' +
'Data from OpenStreetMap ';
const wrapper = mountAttribution(html);
t.equal(
wrapper.text(),
'OpenFreeMap © OpenMapTiles Data from OpenStreetMap',
'links stay separated by single spaces'
);
t.end();
});
test('renderBasemapAttribution -> nested inside does not produce link-in-link', t => {
// invalid markup: an anchor nested inside another anchor. Browsers (and
// JSDOM) auto-close the outer , yielding sibling anchors; the parser must
// never emit an anchor that contains another anchor.
const html = ' outer inner ';
const wrapper = mountAttribution(html);
const container = wrapper.getDOMNode();
const anchorEls = container.querySelectorAll('a');
anchorEls.forEach(a => {
t.equal(a.querySelectorAll('a').length, 0, 'no anchor nested inside another anchor');
});
t.ok(wrapper.text().includes('inner'), 'inner link text preserved');
t.ok(wrapper.text().includes('outer'), 'outer link text preserved');
t.end();
});
test('renderBasemapAttribution -> script/style/template/noscript content is not rendered', t => {
const cases = [
'beforeafter',
'ab',
'chidden d',
'enoscript-text f'
];
cases.forEach(html => {
const wrapper = mountAttribution(html);
t.equal(wrapper.find('script').length, 0, `no script element rendered: ${html}`);
t.equal(wrapper.find('style').length, 0, `no style element rendered: ${html}`);
t.notOk(wrapper.text().includes('alert(1)'), 'script source not surfaced as text');
t.notOk(wrapper.text().includes('color:red'), 'style source not surfaced as text');
t.notOk(wrapper.text().includes('hidden'), 'template content not surfaced as text');
t.notOk(wrapper.text().includes('noscript-text'), 'noscript content not surfaced as text');
});
t.end();
});
test('renderBasemapAttribution -> unsafe/non-allowlisted schemes are dropped, text kept', t => {
const cases = [
{href: '//evil.com', label: 'protocol-relative'},
{href: '/relative/path', label: 'relative'},
{href: 'tel:12345', label: 'tel'},
{href: 'ftp://host/file', label: 'ftp'},
{href: 'data:text/html,x ', label: 'data'},
// eslint-disable-next-line no-script-url
{href: ' javascript:alert(1)', label: 'js with leading space'},
// eslint-disable-next-line no-script-url
{href: 'JAVASCRIPT:alert(1)', label: 'uppercase js'},
{href: 'vbscript:msgbox(1)', label: 'vbscript'}
];
cases.forEach(({href, label}) => {
const wrapper = mountAttribution(`click ${label} `);
t.equal(wrapper.find('a').length, 0, `no link rendered for ${label}`);
t.ok(wrapper.text().includes(`click ${label}`), `text preserved for ${label}`);
});
t.end();
});
test('renderBasemapAttribution -> allowlisted schemes are kept (incl. uppercase, http)', t => {
const cases = [
'http://plain.com',
'https://secure.com',
'HTTPS://UPPER.COM',
'mailto:hi@example.com',
'MAILTO:hi@example.com'
];
cases.forEach(href => {
const wrapper = mountAttribution(`x `);
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, `link rendered for ${href}`);
t.equal(anchors.at(0).prop('href'), href, `href preserved for ${href}`);
t.equal(anchors.at(0).prop('rel'), 'noopener noreferrer', `safe rel for ${href}`);
t.equal(anchors.at(0).prop('target'), '_blank', `target _blank for ${href}`);
});
t.end();
});
test('renderBasemapAttribution -> empty and whitespace-only anchors are dropped', t => {
const empty = mountAttribution(' tail');
t.equal(empty.find('a').length, 0, 'empty anchor is not rendered as a link');
t.ok(empty.text().includes('tail'), 'surrounding text kept');
const wsOnly = mountAttribution(' keep');
t.equal(wsOnly.find('a').length, 0, 'whitespace-only anchor is not rendered as a link');
t.ok(wsOnly.text().includes('keep'), 'surrounding text kept');
t.end();
});
test('renderBasemapAttribution -> event-handler attributes are never carried to output', t => {
// even for a safe href, only href/target/rel are set; inline handlers dropped
const wrapper = mountAttribution(
'y '
);
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'safe anchor rendered');
t.notOk(anchors.at(0).prop('onClick'), 'no onClick handler');
t.notOk(anchors.at(0).prop('onclick'), 'no onclick attribute');
t.notOk(anchors.at(0).prop('style'), 'no inline style carried over');
t.end();
});
test('renderBasemapAttribution -> img/onerror payload does not render an image or execute', t => {
const wrapper = mountAttribution(' visible');
t.equal(wrapper.find('img').length, 0, 'no img element rendered');
t.equal(wrapper.text(), 'visible', 'only surrounding text is rendered');
t.end();
});
test('renderBasemapAttribution -> deeply nested non-anchor markup flattens to text', t => {
const html =
'';
const wrapper = mountAttribution(html);
const anchors = wrapper.find('a');
t.equal(anchors.length, 1, 'the single link is preserved');
t.equal(anchors.at(0).prop('href'), 'https://x.com', 'href preserved through nesting');
t.ok(wrapper.text().includes('Deep text'), 'nested formatting flattened to text');
t.end();
});
test('renderBasemapAttribution -> always returns an array, never throws', t => {
const inputs = [
'',
' ',
'plain',
'no href ',
'empty href ',
'<<>>',
'unclosed',
'© & < > entities'
];
inputs.forEach(html => {
const out = renderBasemapAttribution(html, 'k');
t.ok(Array.isArray(out), `array returned for ${JSON.stringify(html)}`);
});
t.end();
});
test('renderBasemapAttribution -> keys are unique across produced nodes', t => {
const html =
'a one b two c ' +
'three ';
const nodes = renderBasemapAttribution(html, 'k');
const keys = nodes.map(n => n.key);
t.equal(new Set(keys).size, keys.length, 'no duplicate React keys');
t.ok(keys.every(Boolean), 'every node has a key');
t.end();
});
test('dedupeBasemapAttributions -> exact duplicates', t => {
t.deepEqual(
dedupeBasemapAttributions(['© OpenStreetMap', '© OpenStreetMap']),
['© OpenStreetMap'],
'collapses exact duplicates'
);
t.end();
});
test('dedupeBasemapAttributions -> wording variants collapse (OSM vs OSM contributors)', t => {
t.deepEqual(
dedupeBasemapAttributions(['© OpenStreetMap contributors', '© OpenStreetMap']),
['© OpenStreetMap contributors'],
'the standalone OSM string is subsumed by the fuller one'
);
t.end();
});
test('dedupeBasemapAttributions -> standalone OSM link subsumed by CARTO string that links OSM', t => {
const carto =
'© CARTO , © ' +
'OpenStreetMap contributors';
const osm = '© OpenStreetMap ';
t.deepEqual(
dedupeBasemapAttributions([carto, osm]),
[carto],
'OSM-only entry dropped because CARTO already links OSM and the text overlaps'
);
t.end();
});
test('dedupeBasemapAttributions -> distinct providers are all kept', t => {
const ofm = 'OpenFreeMap ';
const omt = '© OpenMapTiles ';
const osm = '© OpenStreetMap ';
t.deepEqual(
dedupeBasemapAttributions([ofm, omt, osm]),
[ofm, omt, osm],
'independent providers are preserved'
);
t.end();
});
test('dedupeBasemapAttributions -> distinct provider not dropped by token cross-contamination', t => {
// "Map Co" is a distinct provider; its tokens (map, co) each appear in a
// *different* earlier entry, but no single earlier entry covers both, so it
// must be kept (guards against union-based false positives)
const a = '© Map Data';
const b = '© Data Co';
const c = '© Map Co';
t.deepEqual(
dedupeBasemapAttributions([a, b, c]),
[a, b, c],
'entry whose tokens span two different kept entries is not subsumed'
);
t.end();
});
test('dedupeBasemapAttributions -> www prefix and casing normalized', t => {
const a = 'OpenStreetMap ';
const b = 'OpenStreetMap contributors ';
t.deepEqual(
dedupeBasemapAttributions([a, b]),
[a],
'same host regardless of www/casing collapses'
);
t.end();
});
test('dedupeBasemapAttributions -> synthesized OSM entry is subsumed by CARTO', t => {
// mirrors the runtime fold-in: a synthesized canonical OSM link should not
// double-render when a CARTO string already links OSM
const carto =
'© CARTO , © ' +
'OpenStreetMap contributors';
const synthesizedOsm = '© OpenStreetMap ';
t.deepEqual(
dedupeBasemapAttributions([carto, synthesizedOsm]),
[carto],
'canonical OSM entry dropped when CARTO already links OSM'
);
t.end();
});
test('dedupeBasemapAttributions -> empty and single-entry inputs', t => {
t.deepEqual(dedupeBasemapAttributions([]), [], 'empty input yields empty output');
t.deepEqual(dedupeBasemapAttributions(['© Solo']), ['© Solo'], 'single entry is kept');
t.end();
});
test('dedupeBasemapAttributions -> order is preserved', t => {
const a = 'Alpha ';
const b = 'Beta ';
const c = 'Gamma ';
t.deepEqual(dedupeBasemapAttributions([c, a, b]), [c, a, b], 'input order preserved');
t.end();
});
test('dedupeBasemapAttributions -> shorter-first: fuller variant adds no new tokens, collapses', t => {
// "© OpenStreetMap" comes first and is kept; the fuller "... contributors"
// normalizes to the same token set ("contributors" is boilerplate), so it is
// subsumed and the shorter (first) entry wins
const osm = '© OpenStreetMap';
const osmFull = '© OpenStreetMap contributors';
t.deepEqual(
dedupeBasemapAttributions([osm, osmFull]),
[osm],
'fuller variant with only boilerplate difference collapses to the first'
);
t.end();
});
test('dedupeBasemapAttributions -> fuller entry with new tokens after a shorter one is kept', t => {
// shorter first; the later entry introduces a genuinely new token (carto), so
// it is NOT subsumed and both are kept
const osm = '© OpenStreetMap';
const both = '© CARTO, © OpenStreetMap';
t.deepEqual(
dedupeBasemapAttributions([osm, both]),
[osm, both],
'later entry with an additional provider is preserved'
);
t.end();
});
test('dedupeBasemapAttributions -> is idempotent', t => {
const carto =
'© CARTO , © ' +
'OpenStreetMap contributors';
const osm = '© OpenStreetMap ';
const once = dedupeBasemapAttributions([carto, osm]);
const twice = dedupeBasemapAttributions(once);
t.deepEqual(twice, once, 'running dedupe again changes nothing');
t.end();
});
test('dedupeBasemapAttributions -> does not mutate its input array', t => {
const input = ['© OpenStreetMap contributors', '© OpenStreetMap'];
const snapshot = [...input];
dedupeBasemapAttributions(input);
t.deepEqual(input, snapshot, 'input array is unchanged');
t.end();
});
test('dedupeBasemapAttributions -> different link hosts are not merged', t => {
const a = 'Map ';
const b = 'Map ';
// same visible text "Map" but different hosts -> both kept (host token differs)
t.deepEqual(
dedupeBasemapAttributions([a, b]),
[a, b],
'same text but distinct hosts are preserved'
);
t.end();
});
test('dedupeBasemapAttributions -> punctuation/casing/whitespace normalized in text', t => {
const a = '© OpenStreetMap Contributors';
const b = '© openstreetmap, contributors';
t.deepEqual(
dedupeBasemapAttributions([a, b]),
[a],
'text normalized (case, punctuation, whitespace, "contributors") collapses'
);
t.end();
});
test('dedupeBasemapAttributions -> whitespace-only entries are dropped as empty signatures', t => {
// exact-dup path keeps the first; a second identical whitespace entry is a
// duplicate string so it is removed
t.deepEqual(dedupeBasemapAttributions([' ', ' ']), [' '], 'duplicate blank collapses');
t.end();
});