mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-04 10:24:02 +00:00
Mazeyar Moeini Feizabadi
5ea6d81310
Normalize GeoJSON ground footprints, preserve explicit KML track heights, and tessellate ground paths before native loading. Validate coordinates, geometry types and decoded image budgets before allocating native resources; strip loader-sensitive metadata and settle deferred failures and cancellation. Render static pins in owned billboard collections instead of walking tens of thousands of point entities each frame. Refine nearby ground heights in batches, isolate imported pins from height picks, and release owned resources and point selections on removal. Use safe ray origins above a hidden coarse globe and retain valid mesh heights outside the current footprint. Frame complete geometry with viewport-aware nadir arrivals, including walls and rotated overlays; respect camera gestures and accept document file drops. Strengthen real-loader, native 3D Tiles, paint, clock and lifecycle coverage. Addresses both P1 and all 25 P2 findings in the follow-up review of #1122.
701 lines
22 KiB
JavaScript
701 lines
22 KiB
JavaScript
// Behavioral tests for DISPLAY ▸ Import: the controller is driven against
|
|
// fake DOM and viewer doubles with an injected loader, and its observable
|
|
// effects are asserted — data sources added and removed, list rows, the hint,
|
|
// drop handling, the file limit, and what destroy() gives back. Real parsing
|
|
// and rendering run in `scripts/qa-geo-import.mjs`.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import { initGeoFileImport, summarize } from './geoFileImport.js';
|
|
import { GeoImportError, MAX_IMPORTED_FILES } from '../data/geoFileImport.js';
|
|
|
|
class FakeClassList {
|
|
constructor() {
|
|
this.names = new Set();
|
|
}
|
|
add(...n) {
|
|
n.forEach((x) => this.names.add(x));
|
|
}
|
|
remove(...n) {
|
|
n.forEach((x) => this.names.delete(x));
|
|
}
|
|
contains(n) {
|
|
return this.names.has(n);
|
|
}
|
|
toggle(n, force) {
|
|
const on = force === undefined ? !this.names.has(n) : Boolean(force);
|
|
if (on) this.names.add(n);
|
|
else this.names.delete(n);
|
|
return on;
|
|
}
|
|
}
|
|
|
|
// The one focused element across every fake document (tests run one at a time).
|
|
const focus = { active: null };
|
|
|
|
class FakeElement {
|
|
constructor(tagName = 'div', id = '') {
|
|
this.tagName = tagName.toUpperCase();
|
|
this.id = id;
|
|
this.classList = new FakeClassList();
|
|
this.dataset = {};
|
|
this.style = {};
|
|
this.attributes = new Map();
|
|
this.children = [];
|
|
this.parent = null;
|
|
this.listeners = [];
|
|
this.textContent = '';
|
|
this.value = '';
|
|
this.clicks = 0;
|
|
}
|
|
set className(v) {
|
|
this.classList = new FakeClassList();
|
|
String(v)
|
|
.split(/\s+/)
|
|
.filter(Boolean)
|
|
.forEach((n) => this.classList.add(n));
|
|
}
|
|
setAttribute(n, v) {
|
|
this.attributes.set(n, String(v));
|
|
}
|
|
getAttribute(n) {
|
|
return this.attributes.get(n) ?? null;
|
|
}
|
|
append(...kids) {
|
|
for (const k of kids) {
|
|
k.parent = this;
|
|
this.children.push(k);
|
|
}
|
|
}
|
|
replaceChildren(...kids) {
|
|
this.children = [];
|
|
this.append(...kids);
|
|
}
|
|
addEventListener(type, listener, options) {
|
|
this.listeners.push({ type, listener, options });
|
|
}
|
|
removeEventListener(type, listener) {
|
|
const at = this.listeners.findIndex(
|
|
(l) => l.type === type && l.listener === listener,
|
|
);
|
|
if (at >= 0) this.listeners.splice(at, 1);
|
|
}
|
|
emit(type, event = {}) {
|
|
for (const { listener } of this.listeners.filter((l) => l.type === type))
|
|
listener({
|
|
target: this,
|
|
preventDefault() {
|
|
this.prevented = true;
|
|
},
|
|
...event,
|
|
});
|
|
}
|
|
click() {
|
|
this.clicks += 1;
|
|
this.emit('click');
|
|
}
|
|
focus() {
|
|
focus.active = this;
|
|
}
|
|
contains(el) {
|
|
for (let at = el; at; at = at.parent) if (at === this) return true;
|
|
return false;
|
|
}
|
|
*walk() {
|
|
for (const kid of this.children) {
|
|
yield kid;
|
|
yield* kid.walk();
|
|
}
|
|
}
|
|
querySelectorAll(selector) {
|
|
if (selector !== '[data-import-id]') throw new Error(`fake: ${selector}`);
|
|
return [...this.walk()].filter((el) => el.dataset.importId);
|
|
}
|
|
querySelector(selector) {
|
|
const exact = /^button\[data-action="([a-z]+)"\]$/.exec(selector);
|
|
for (const el of this.walk()) {
|
|
if (el.tagName !== 'BUTTON') continue;
|
|
if (selector === 'button' || (exact && el.dataset.action === exact[1]))
|
|
return el;
|
|
}
|
|
return null;
|
|
}
|
|
closest(selector) {
|
|
for (let el = this; el; el = el.parent) {
|
|
if (
|
|
selector === 'button[data-action]' &&
|
|
el.tagName === 'BUTTON' &&
|
|
el.dataset.action
|
|
)
|
|
return el;
|
|
if (selector === '[data-import-id]' && el.dataset.importId) return el;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function setup({ load, navigation, flyToSource, subscribeMapSource } = {}) {
|
|
focus.active = null;
|
|
const els = {
|
|
'geo-import-button': new FakeElement('button', 'geo-import-button'),
|
|
'geo-import-input': new FakeElement('input', 'geo-import-input'),
|
|
'geo-import-list': new FakeElement('ul', 'geo-import-list'),
|
|
'geo-import-hint': new FakeElement('span', 'geo-import-hint'),
|
|
};
|
|
const document = {
|
|
body: new FakeElement('body'),
|
|
getElementById: (id) => els[id] ?? null,
|
|
createElement: (tag) => new FakeElement(tag),
|
|
get activeElement() {
|
|
return focus.active;
|
|
},
|
|
};
|
|
Object.setPrototypeOf(document, new FakeElement('document'));
|
|
const added = [];
|
|
const removed = [];
|
|
const flights = [];
|
|
let renders = 0;
|
|
const viewer = {
|
|
container: new FakeElement('div', 'cesiumContainer'),
|
|
scene: { requestRender: () => (renders += 1) },
|
|
dataSources: {
|
|
add: async (ds) => {
|
|
added.push(ds);
|
|
return ds;
|
|
},
|
|
remove: (ds, destroy) => {
|
|
removed.push({ ds, destroy });
|
|
return true;
|
|
},
|
|
},
|
|
flyTo: (target) => flights.push(target),
|
|
};
|
|
const revoked = [];
|
|
const loads = [];
|
|
const defaultLoad = async (file, opts) => {
|
|
loads.push({ file, opts });
|
|
if (file.fail) throw new GeoImportError(file.fail);
|
|
if (file.crash) throw new Error('boom');
|
|
return {
|
|
dataSource: { show: true },
|
|
name: file.name,
|
|
format: 'geojson',
|
|
entityCount: 3,
|
|
removed: file.removed || 0,
|
|
revoke: () => revoked.push(file.name),
|
|
};
|
|
};
|
|
const tool = initGeoFileImport({
|
|
viewer,
|
|
load: load || defaultLoad,
|
|
document,
|
|
...(navigation ? { navigation } : {}),
|
|
...(subscribeMapSource ? { subscribeMapSource } : {}),
|
|
flyToSource: flyToSource || ((_viewer, ds) => flights.push(ds)),
|
|
});
|
|
return {
|
|
tool,
|
|
els,
|
|
document,
|
|
viewer,
|
|
added,
|
|
removed,
|
|
flights,
|
|
revoked,
|
|
loads,
|
|
renders: () => renders,
|
|
};
|
|
}
|
|
const file = (name, extra = {}) => ({ name, size: 10, ...extra });
|
|
const rows = (els) => els['geo-import-list'].children;
|
|
const action = (row, name) =>
|
|
row.children.find((c) => c.dataset.action === name);
|
|
|
|
test('returns null without its markup or viewer', () => {
|
|
const document = { getElementById: () => null };
|
|
assert.equal(initGeoFileImport({ viewer: {}, document }), null);
|
|
assert.equal(
|
|
initGeoFileImport({
|
|
viewer: null,
|
|
document: { getElementById: () => new FakeElement() },
|
|
}),
|
|
null,
|
|
);
|
|
});
|
|
|
|
test('the Import button opens the picker and a pick imports each file', async () => {
|
|
const t = setup();
|
|
t.els['geo-import-button'].click();
|
|
assert.equal(t.els['geo-import-input'].clicks, 1);
|
|
assert.equal(
|
|
t.els['geo-import-input'].accept,
|
|
'.geojson,.json,.kml,.kmz,.gpx',
|
|
);
|
|
const out = await t.tool.importFiles([file('a.geojson'), file('b.kml')]);
|
|
assert.deepEqual(
|
|
out.map((o) => o.ok),
|
|
[true, true],
|
|
);
|
|
assert.equal(t.added.length, 2);
|
|
assert.notEqual(
|
|
t.loads[0].opts.color,
|
|
t.loads[1].opts.color,
|
|
'each file gets its own color',
|
|
);
|
|
assert.equal(rows(t.els).length, 2);
|
|
assert.ok(t.els['geo-import-list'].classList.contains('visible'));
|
|
assert.equal(t.flights.length, 1, 'the first file of a batch is flown to');
|
|
assert.equal(t.els['geo-import-hint'].textContent, 'Added 2 files.');
|
|
assert.deepEqual(
|
|
t.tool.list().map((f) => f.name),
|
|
['a.geojson', 'b.kml'],
|
|
);
|
|
});
|
|
|
|
test('file names are text, never markup', async () => {
|
|
const t = setup();
|
|
await t.tool.importFiles([file('<img src=x onerror=alert(1)>.kml')]);
|
|
const name = rows(t.els)[0].children.find((c) =>
|
|
c.classList.contains('geo-import-name'),
|
|
);
|
|
assert.equal(name.textContent, '<img src=x onerror=alert(1)>.kml');
|
|
assert.equal(name.innerHTML, undefined);
|
|
});
|
|
|
|
test('row buttons hide, show, fly to and remove a file', async () => {
|
|
const t = setup();
|
|
await t.tool.importFiles([file('a.gpx')]);
|
|
const [{ id }] = t.tool.list();
|
|
const ds = t.added[0];
|
|
// the click lands on the glyph inside the button, as in a browser
|
|
const glyphClick = (name) =>
|
|
t.els['geo-import-list'].emit('click', {
|
|
target: action(rows(t.els)[0], name).children[0],
|
|
});
|
|
assert.equal(ds.show, true);
|
|
glyphClick('toggle');
|
|
assert.equal(ds.show, false);
|
|
assert.equal(t.tool.list()[0].visible, false);
|
|
assert.equal(
|
|
action(rows(t.els)[0], 'toggle').getAttribute('aria-pressed'),
|
|
'false',
|
|
);
|
|
glyphClick('fly');
|
|
assert.equal(ds.show, true, 'flying to a hidden file shows it');
|
|
assert.equal(t.flights.at(-1), ds);
|
|
glyphClick('remove');
|
|
assert.deepEqual(t.removed, [{ ds, destroy: true }]);
|
|
assert.deepEqual(t.revoked, ['a.gpx']);
|
|
assert.equal(t.tool.list().length, 0);
|
|
assert.ok(!t.els['geo-import-list'].classList.contains('visible'));
|
|
assert.equal(t.tool.remove(id), false);
|
|
});
|
|
|
|
test('a refused file says why and does not stop the rest of the batch', async () => {
|
|
const t = setup();
|
|
const out = await t.tool.importFiles([
|
|
file('bad.kml', { fail: 'That KML file is not valid XML.' }),
|
|
file('odd.gpx', { crash: true }),
|
|
file('good.geojson'),
|
|
]);
|
|
assert.deepEqual(
|
|
out.map((o) => o.ok),
|
|
[false, false, true],
|
|
);
|
|
assert.equal(out[0].error, 'That KML file is not valid XML.');
|
|
assert.match(out[1].error, /could not be read\./);
|
|
assert.match(
|
|
t.els['geo-import-hint'].textContent,
|
|
/^Added 1 file\. 2 files could not be added \(bad\.kml: That KML file is not valid XML\.\)/,
|
|
);
|
|
assert.equal(t.tool.list().length, 1);
|
|
});
|
|
|
|
test('the number of files on the globe is bounded', async () => {
|
|
const t = setup();
|
|
const many = Array.from({ length: MAX_IMPORTED_FILES + 2 }, (_, i) =>
|
|
file(`f${i}.geojson`),
|
|
);
|
|
const out = await t.tool.importFiles(many);
|
|
assert.equal(out.filter((o) => o.ok).length, MAX_IMPORTED_FILES);
|
|
assert.match(out.at(-1).error, /At most 12 files/);
|
|
assert.equal(
|
|
t.loads.length,
|
|
MAX_IMPORTED_FILES,
|
|
'files over the limit are not even read',
|
|
);
|
|
});
|
|
|
|
test('dropping files on the globe imports them; other drags are left alone', async () => {
|
|
const t = setup();
|
|
const c = t.viewer.container;
|
|
const files = { types: ['Files'], files: [file('drop.kmz')] };
|
|
let ev = { dataTransfer: { types: ['text/plain'] } };
|
|
t.document.emit('dragover', ev);
|
|
c.emit('dragenter', { dataTransfer: files });
|
|
assert.ok(t.document.body.classList.contains('gev-geo-import-drag'));
|
|
c.emit('dragleave', { dataTransfer: files });
|
|
assert.ok(!t.document.body.classList.contains('gev-geo-import-drag'));
|
|
c.emit('dragenter', { dataTransfer: files });
|
|
t.document.emit('drop', { dataTransfer: files });
|
|
assert.ok(!t.document.body.classList.contains('gev-geo-import-drag'));
|
|
await new Promise((r) => setImmediate(r));
|
|
assert.deepEqual(
|
|
t.tool.list().map((f) => f.name),
|
|
['drop.kmz'],
|
|
);
|
|
});
|
|
|
|
test('stripped KML content is mentioned once, for the batch that had it', () => {
|
|
assert.equal(
|
|
summarize([{ name: 'a.kml', ok: true, removed: 3 }]),
|
|
'Added 1 file. Some KML content was left out.',
|
|
);
|
|
assert.equal(
|
|
summarize([{ name: 'b.geojson', ok: true, removed: 0 }]),
|
|
'Added 1 file.',
|
|
);
|
|
});
|
|
|
|
test('destroy removes every file and listener and the window handle', async () => {
|
|
globalThis.window = {};
|
|
try {
|
|
const t = setup();
|
|
assert.equal(globalThis.window.__gevGeoImport, t.tool);
|
|
await t.tool.importFiles([file('a.geojson'), file('b.geojson')]);
|
|
t.tool.destroy();
|
|
assert.equal(t.removed.length, 2);
|
|
assert.deepEqual(t.revoked.sort(), ['a.geojson', 'b.geojson']);
|
|
for (const el of [
|
|
t.viewer.container,
|
|
t.els['geo-import-button'],
|
|
t.els['geo-import-input'],
|
|
t.els['geo-import-list'],
|
|
])
|
|
assert.equal(el.listeners.length, 0);
|
|
assert.equal(rows(t.els).length, 0);
|
|
assert.equal(globalThis.window.__gevGeoImport, undefined);
|
|
assert.equal(t.tool.diagnostics().destroyed, true);
|
|
} finally {
|
|
delete globalThis.window;
|
|
}
|
|
});
|
|
|
|
test('a file that finishes loading after destroy is released, not added', async () => {
|
|
let release;
|
|
const gate = new Promise((r) => (release = r));
|
|
const revoked = [];
|
|
const t = setup({
|
|
load: async () => {
|
|
await gate;
|
|
return {
|
|
dataSource: {},
|
|
name: 'late',
|
|
format: 'kml',
|
|
entityCount: 1,
|
|
removed: 0,
|
|
revoke: () => revoked.push('late'),
|
|
};
|
|
},
|
|
});
|
|
const pending = t.tool.importFiles([file('late.kml')]);
|
|
// Imports are queued: let the batch start loading before destroy lands.
|
|
await new Promise((r) => setImmediate(r));
|
|
t.tool.destroy();
|
|
release();
|
|
await pending;
|
|
assert.equal(t.added.length, 0);
|
|
assert.deepEqual(revoked, ['late']);
|
|
});
|
|
|
|
test('the application composition wires the import and owns its teardown', () => {
|
|
const tools = fs.readFileSync(
|
|
new URL('../app/tools.js', import.meta.url),
|
|
'utf8',
|
|
);
|
|
const drawAt = tools.indexOf(
|
|
'const drawTool = initDrawTool({ viewer, annotations });',
|
|
);
|
|
const importAt = tools.indexOf('const geoFileImport = initGeoFileImport({');
|
|
assert.ok(importAt > drawAt && drawAt >= 0);
|
|
// Fly-to goes through the application shell's navigation policy.
|
|
assert.match(
|
|
tools.slice(importAt, importAt + 200),
|
|
/navigation: styleManager/,
|
|
);
|
|
assert.ok(tools.indexOf('defer(() => geoFileImport?.destroy());') > importAt);
|
|
const markup = fs.readFileSync(
|
|
new URL('./templates/display-controls.html', import.meta.url),
|
|
'utf8',
|
|
);
|
|
for (const id of [
|
|
'geo-import-button',
|
|
'geo-import-input',
|
|
'geo-import-list',
|
|
'geo-import-hint',
|
|
])
|
|
assert.ok(
|
|
markup.includes(`id="${id}"`),
|
|
`${id} missing from the DISPLAY template`,
|
|
);
|
|
});
|
|
|
|
test('two imports at once never pass the file cap: batches run one after another', async () => {
|
|
const t = setup();
|
|
const first = t.tool.importFiles(
|
|
Array.from({ length: 8 }, (_, i) => file(`a${i}.geojson`)),
|
|
);
|
|
const second = t.tool.importFiles(
|
|
Array.from({ length: 8 }, (_, i) => file(`b${i}.geojson`)),
|
|
);
|
|
const [a, b] = await Promise.all([first, second]);
|
|
assert.equal(t.tool.list().length, MAX_IMPORTED_FILES);
|
|
assert.equal(a.filter((o) => o.ok).length, 8);
|
|
assert.equal(b.filter((o) => o.ok).length, MAX_IMPORTED_FILES - 8);
|
|
assert.equal(b.filter((o) => !o.ok).length, 16 - MAX_IMPORTED_FILES);
|
|
// The second batch's loads started only after the first batch finished.
|
|
assert.deepEqual(
|
|
t.loads.map((l) => l.file.name.slice(0, 1)).join(''),
|
|
'a'.repeat(8) + 'b'.repeat(MAX_IMPORTED_FILES - 8),
|
|
);
|
|
});
|
|
|
|
function navigationDouble({ immediate = true, reassert = true } = {}) {
|
|
const calls = [];
|
|
let generation = 0;
|
|
return {
|
|
calls,
|
|
runImmediateNavigation(noun, navigate) {
|
|
calls.push(['immediate', noun]);
|
|
return immediate ? navigate(++generation) : false;
|
|
},
|
|
beginDeferredLocationNavigation() {
|
|
calls.push(['begin']);
|
|
return ++generation;
|
|
},
|
|
reassertDeferredLocationNavigation(g) {
|
|
calls.push(['reassert', g]);
|
|
return reassert;
|
|
},
|
|
};
|
|
}
|
|
|
|
test('a direct camera gesture cancels the fly-to of a file still being read', async () => {
|
|
for (const gesture of ['pointerdown', 'wheel']) {
|
|
let release;
|
|
const t = setup({
|
|
load: async () => {
|
|
await new Promise((r) => (release = r));
|
|
return {
|
|
name: 'slow.geojson',
|
|
format: 'geojson',
|
|
entityCount: 1,
|
|
dataSource: {},
|
|
};
|
|
},
|
|
});
|
|
const result = t.tool.importFiles([file('slow.geojson')]);
|
|
await new Promise((r) => setImmediate(r));
|
|
t.viewer.container.emit(gesture);
|
|
release();
|
|
await result;
|
|
assert.equal(t.added.length, 1);
|
|
assert.equal(t.flights.length, 0);
|
|
t.tool.destroy();
|
|
assert.equal(t.document.listeners.length, 0);
|
|
}
|
|
});
|
|
|
|
test('dropping on panel controls is accepted and file drags prevent browser navigation', async () => {
|
|
const t = setup();
|
|
let prevented = 0;
|
|
const event = {
|
|
target: t.els['geo-import-button'],
|
|
dataTransfer: { types: ['Files'], files: [file('panel.kml')] },
|
|
preventDefault: () => prevented++,
|
|
};
|
|
t.document.emit('dragover', event);
|
|
t.document.emit('drop', event);
|
|
await new Promise((r) => setImmediate(r));
|
|
assert.equal(prevented, 2);
|
|
assert.equal(t.tool.list()[0].name, 'panel.kml');
|
|
t.tool.destroy();
|
|
assert.equal(t.document.listeners.length, 0);
|
|
});
|
|
|
|
test('ground refresh coalesces map changes and releases its subscription on teardown', async () => {
|
|
let changed,
|
|
unsubscribed = 0,
|
|
refreshed = 0;
|
|
const t = setup({
|
|
subscribeMapSource: (listener) => {
|
|
changed = listener;
|
|
return () => unsubscribed++;
|
|
},
|
|
load: async () => ({
|
|
name: 'point.geojson',
|
|
format: 'geojson',
|
|
entityCount: 1,
|
|
dataSource: {},
|
|
refreshGround: async () => refreshed++,
|
|
}),
|
|
});
|
|
await t.tool.importFiles([file('point.geojson')]);
|
|
changed();
|
|
changed();
|
|
changed();
|
|
await new Promise((resolve) => setTimeout(resolve, 300));
|
|
assert.equal(refreshed, 1);
|
|
t.tool.destroy();
|
|
changed();
|
|
await new Promise((resolve) => setTimeout(resolve, 250));
|
|
assert.equal(refreshed, 1);
|
|
assert.equal(unsubscribed, 1);
|
|
});
|
|
|
|
test('Fly to is an immediate navigation that Cockpit can refuse', async () => {
|
|
const flown = [];
|
|
const nav = navigationDouble({ immediate: false });
|
|
const t = setup({ navigation: nav, flyToSource: (v, ds) => flown.push(ds) });
|
|
// Batch auto-fly is deferred: stamped at the start, re-asserted before flying.
|
|
await t.tool.importFiles([file('a.geojson')]);
|
|
assert.deepEqual(nav.calls, [['begin'], ['reassert', 1]]);
|
|
assert.equal(flown.length, 1);
|
|
// The button goes through the immediate route; refused, nothing flies.
|
|
const id = t.tool.list()[0].id;
|
|
assert.equal(t.tool.flyTo(id), false);
|
|
assert.deepEqual(nav.calls.at(-1), ['immediate', 'file']);
|
|
assert.equal(flown.length, 1);
|
|
const nav2 = navigationDouble();
|
|
const t2 = setup({
|
|
navigation: nav2,
|
|
flyToSource: (v, ds) => flown.push(ds),
|
|
});
|
|
await t2.tool.importFiles([file('b.geojson')]);
|
|
assert.equal(t2.tool.flyTo(t2.tool.list()[0].id), true);
|
|
assert.equal(flown.length, 3);
|
|
});
|
|
|
|
test('a slow import does not fly once something newer took the camera', async () => {
|
|
let release;
|
|
const gate = new Promise((r) => (release = r));
|
|
const flown = [];
|
|
const nav = navigationDouble({ reassert: false });
|
|
const t = setup({
|
|
navigation: nav,
|
|
flyToSource: (v, ds) => flown.push(ds),
|
|
load: async (f) => {
|
|
await gate;
|
|
return {
|
|
dataSource: {},
|
|
name: f.name,
|
|
format: 'geojson',
|
|
entityCount: 1,
|
|
removed: 0,
|
|
revoke() {},
|
|
};
|
|
},
|
|
});
|
|
const pending = t.tool.importFiles([file('slow.geojson')]);
|
|
release();
|
|
const [out] = await pending;
|
|
assert.equal(out.ok, true);
|
|
assert.deepEqual(nav.calls, [['begin'], ['reassert', 1]]);
|
|
assert.equal(flown.length, 0);
|
|
});
|
|
|
|
test('a queued import cannot fly over navigation that happened while it waited', async () => {
|
|
let release;
|
|
const gate = new Promise((resolve) => {
|
|
release = resolve;
|
|
});
|
|
let generation = 0;
|
|
const flown = [];
|
|
const nav = {
|
|
beginDeferredLocationNavigation: () => ++generation,
|
|
reassertDeferredLocationNavigation: (stamp) => stamp === generation,
|
|
};
|
|
const t = setup({
|
|
navigation: nav,
|
|
flyToSource: (v, ds) => flown.push(ds),
|
|
load: async (f) => {
|
|
if (f.name === 'first.geojson') await gate;
|
|
return {
|
|
dataSource: {},
|
|
name: f.name,
|
|
format: 'geojson',
|
|
entityCount: 1,
|
|
revoke() {},
|
|
};
|
|
},
|
|
});
|
|
const first = t.tool.importFiles([file('first.geojson')]);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const queued = t.tool.importFiles([file('queued.geojson')]);
|
|
generation++; // A newer user camera action while the second batch is waiting.
|
|
release();
|
|
const results = await Promise.all([first, queued]);
|
|
assert.ok(results.every(([outcome]) => outcome.ok));
|
|
assert.equal(t.tool.list().length, 2);
|
|
assert.equal(flown.length, 0);
|
|
});
|
|
|
|
test('a refused deferred stamp (Cockpit) imports without flying', async () => {
|
|
const flown = [];
|
|
const nav = navigationDouble();
|
|
nav.beginDeferredLocationNavigation = () => false;
|
|
nav.reassertDeferredLocationNavigation = () => {
|
|
throw new Error('must not re-assert a refused stamp');
|
|
};
|
|
const t = setup({ navigation: nav, flyToSource: (v, ds) => flown.push(ds) });
|
|
const [out] = await t.tool.importFiles([file('a.geojson')]);
|
|
assert.equal(out.ok, true);
|
|
assert.equal(flown.length, 0);
|
|
});
|
|
|
|
test('keyboard focus stays on the control after hide, show and remove', async () => {
|
|
const t = setup();
|
|
await t.tool.importFiles([file('a.geojson'), file('b.geojson')]);
|
|
// Clicks reach the list's delegated listener, as they bubble in a page.
|
|
const press = (btn) =>
|
|
t.els['geo-import-list'].emit('click', { target: btn });
|
|
const [first] = rows(t.els);
|
|
action(first, 'toggle').focus();
|
|
press(action(first, 'toggle'));
|
|
// The list was rebuilt; focus is on the NEW toggle of the same row.
|
|
const again = rows(t.els)[0];
|
|
assert.notEqual(again, first);
|
|
assert.equal(t.document.activeElement, action(again, 'toggle'));
|
|
assert.equal(action(again, 'toggle').getAttribute('aria-pressed'), 'false');
|
|
press(action(again, 'toggle'));
|
|
assert.equal(t.document.activeElement, action(rows(t.els)[0], 'toggle'));
|
|
// Remove the first row: focus moves to the same control on the next row.
|
|
action(rows(t.els)[0], 'remove').focus();
|
|
press(action(rows(t.els)[0], 'remove'));
|
|
assert.equal(rows(t.els).length, 1);
|
|
assert.equal(t.document.activeElement, action(rows(t.els)[0], 'remove'));
|
|
// Remove the last row: focus goes back to the Import button.
|
|
press(action(rows(t.els)[0], 'remove'));
|
|
assert.equal(t.document.activeElement, t.els['geo-import-button']);
|
|
});
|
|
|
|
test('KML and KMZ rows say they keep their own styles instead of showing a color', async () => {
|
|
const t = setup({
|
|
load: async (f) => ({
|
|
dataSource: {},
|
|
name: f.name,
|
|
format: f.name.endsWith('.kml') ? 'kml' : 'gpx',
|
|
entityCount: 2,
|
|
removed: 0,
|
|
revoke() {},
|
|
}),
|
|
});
|
|
await t.tool.importFiles([file('a.kml'), file('b.gpx')]);
|
|
const [kml, gpx] = rows(t.els);
|
|
assert.ok(kml.children[0].classList.contains('own-styles'));
|
|
assert.equal(kml.children[0].style.background, undefined);
|
|
assert.match(kml.children[1].title, /drawn with its own styles/);
|
|
assert.ok(!gpx.children[0].classList.contains('own-styles'));
|
|
assert.ok(gpx.children[0].style.background);
|
|
});
|