Most of the builtin apps had some padding between the window edge and their content, because they expect to be displayed with a line border on their edge. We added a customization option to remove the border, so, that padding is not always necessary. Make the layouts dynamically adjust, to omit the padding when it isn't needed.
235 lines
13 KiB
JavaScript
235 lines
13 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const vm = require('node:vm');
|
|
const ts = require('typescript');
|
|
const path = require('node:path');
|
|
const { loader } = require('./helpers/load-typescript.cjs');
|
|
const { bordered, unbordered, edged } = require('./helpers/viewport.cjs');
|
|
const flush = () => new Promise(resolve => setImmediate(resolve));
|
|
|
|
const route = { coordinates: [[-122.4, 37.7], [-122.4, 37.71]], distanceMeters: 1112, durationSec: 600,
|
|
steps: [{ distanceMeters: 1112, durationSec: 600, instruction: 'Head north', maneuverType: 'depart' },
|
|
{ distanceMeters: 0, durationSec: 0, instruction: 'Arrive', maneuverType: 'arrive' }] };
|
|
const fix = latitude => ({ latitude, longitude: -122.4, timestampMs: Date.now(), bearingDeg: 0, speedMps: 1.5, accuracyMeters: 5 });
|
|
function fixture() {
|
|
const messages = [], timers = new Set(), timeouts = new Set(), holds = [], maps = [], errors = [], requests = [];
|
|
let callbacks, compass, delayRoute = null, delayMap = null, routeError = null, distanceUnit = 'miles', timeFormat = '24h', paints = 0;
|
|
const routeMath = loader()('app/apps/navigate/route-follower.ts');
|
|
const tracker = { running: false, isRunning() { return this.running; }, start() { this.running = true; }, stop() { this.running = false; } };
|
|
const sensor = { LocationTracker: function (value) { callbacks = value; return tracker; }, COMPASS_CHANGED: 15,
|
|
addCompassListener: fn => { compass = fn; return () => { compass = null; }; },
|
|
setCompassEnabled: value => holds.push(value), magneticDeclinationDegrees: () => 12,
|
|
handleNavigationSensorEvent: event => { if (event.kind === 'location') callbacks.onLocation(event.location); } };
|
|
const modules = {
|
|
'@nativescript/core/globals': {},
|
|
// The footer hint's line height sets how much of the window the map-mode map gets.
|
|
'../../graphics/bdffont': { getFont: () => ({}) }, '../../graphics/ui-fonts': { getDefaultSmallFont: () => ({ lineHeight: 12 }) },
|
|
'../../native/settings-store': { onSettingsStoreChanged() {} },
|
|
'../../ui/dashboard-settings': { distanceUnitSetting: { get: () => distanceUnit } },
|
|
'../../ui/clock-format': loader({}, { './dashboard-settings': { timeFormatSetting: { get: () => timeFormat } } })('app/ui/clock-format.ts'),
|
|
'./navigation-sensors': sensor,
|
|
'./route-follower': routeMath,
|
|
'./destinations': { findSavedDestinationByName: () => null, rememberRecentDestination() {},
|
|
loadSavedDestinations: () => [{ name: 'Home', address: '123 Main St' }], loadRecentDestinations: () => [] },
|
|
'../compass/calibration': { calibrateHeading: value => value + 5, normalizeHeading: value => (value + 360) % 360 },
|
|
'../../native/frame-timings': { startFrame: () => 1, finishFrame() {}, logFrame() {}, span: (_id, _name, fn) => fn(), runWithFrame: (_id, fn) => fn() },
|
|
'../../native/active-display': { getActiveDisplay: () => null },
|
|
'../../ui/menu-core': require('../.test-build/app/ui/menu-core.js'),
|
|
'../../ui/window-menu': { WindowMenu: class { paint() { paints++; return []; } isOpen() { return false; } resize() {} } },
|
|
'../../ui/viewport': require('../.test-build/app/ui/viewport.js'),
|
|
'../../graphics/plane': { planesFingerprint: () => 'frame' },
|
|
'../../native/mapbox': {
|
|
isMapboxConfigured: () => true,
|
|
geocodeForward: async () => { requests.push('geocode'); return [{ name: 'Test park', placeFormatted: 'San Francisco', latitude: 37.71, longitude: -122.4 }]; },
|
|
fetchRoute: async () => { requests.push('route'); if (routeError) throw routeError; return delayRoute ? await delayRoute : route; },
|
|
fetchStaticMapGray: async options => { maps.push(options); return delayMap ? await delayMap : { pixels: new Uint8Array([0, 128, 255]) }; },
|
|
},
|
|
};
|
|
const global = { postMessage: message => messages.push(message) };
|
|
const source = fs.readFileSync(path.join(__dirname, '../app/apps/navigate/navigate-app.worker.ts'), 'utf8') +
|
|
'\nexports.probe = { startNavigation, startMap, stopNavigation, idleEntries, describeRouteStatus, state: () => ({ phase, headHeadingDeg, progress, mapImage, mapInFlight, mapLastError }) };';
|
|
const exports = {};
|
|
vm.runInNewContext(ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 } }).outputText, {
|
|
exports, global, Uint8Array,
|
|
setTimeout: fn => { timeouts.add(fn); return fn; }, clearTimeout: fn => timeouts.delete(fn),
|
|
setInterval: fn => { timers.add(fn); return fn; }, clearInterval: fn => timers.delete(fn),
|
|
console: { log() {}, warn() {}, error: error => errors.push(error) }, require: id => modules[id] ?? {},
|
|
});
|
|
const send = data => global.onmessage({ data });
|
|
send({ type: 'open-window', windowId: 'navigate:main', surfaceId: 'window:navigate:main', title: 'Navigate', viewport: bordered(576, 480) });
|
|
send({ type: 'foreground', windowId: 'navigate:main', foreground: true, focused: true });
|
|
return { ...exports.probe, send, timers, holds, maps, errors, tracker, requests, paints: () => paints,
|
|
input: type => send({ type: 'input', windowId: 'navigate:main', focused: true, frameId: 1, event: { type } }),
|
|
tick: () => { for (const callback of timers) callback(); },
|
|
expireFix: () => { for (const callback of timeouts) callback(); timeouts.clear(); },
|
|
failRoute: () => { routeError = new Error('Route unavailable'); },
|
|
setDistanceUnit: value => { distanceUnit = value; },
|
|
setTimeFormat: value => { timeFormat = value; },
|
|
fix: latitude => send({ type: 'navigation-sensors', event: { kind: 'location', location: fix(latitude), id: 1 } }),
|
|
heading: value => compass?.({ command: 15, headingDegrees: value }),
|
|
holdMap: () => { let resolve, reject; delayMap = new Promise((done, fail) => { resolve = done; reject = fail; });
|
|
return { resolve: () => resolve({ pixels: new Uint8Array([0, 128, 255]) }), reject }; },
|
|
holdRoute: () => { let resolve; delayRoute = new Promise(done => { resolve = done; }); return () => resolve(route); } };
|
|
}
|
|
|
|
test('shared Navigate worker follows streamed GPS, uses calibrated true heading and stops at arrival', async () => {
|
|
const h = fixture(); const starting = h.startNavigation('Test park', 'walking');
|
|
h.fix(37.7); assert.match(await starting, /Navigating to Test park/); await flush();
|
|
assert.equal(h.state().phase, 'navigating'); assert.ok(h.maps.length > 0);
|
|
h.heading(90); assert.equal(h.state().headHeadingDeg, 107);
|
|
h.send({ type: 'screen', on: false }); assert.equal(h.holds.at(-1), false); assert.equal(h.tracker.running, true);
|
|
h.fix(37.705); assert.ok(h.state().progress.remainingMeters < 600);
|
|
h.fix(37.71); assert.equal(h.state().phase, 'arrived'); assert.equal(h.tracker.running, false);
|
|
assert.equal(h.timers.size, 0); assert.deepEqual(h.errors, []);
|
|
});
|
|
|
|
test('route distances follow the distance unit setting', async () => {
|
|
const h = fixture(); const starting = h.startNavigation('Test park', 'walking');
|
|
h.fix(37.7); assert.match(await starting, /: 0\.7 mi, about 10 minutes/);
|
|
h.fix(37.705); assert.match(h.describeRouteStatus(), /in 0\.3 mi\. 0\.3 mi and/);
|
|
h.setDistanceUnit('kilometers'); assert.match(h.describeRouteStatus(), /in 550 m\. 550 m and/);
|
|
});
|
|
|
|
test('arrival times follow the time format setting', async () => {
|
|
const h = fixture(); const starting = h.startNavigation('Test park', 'walking');
|
|
h.fix(37.7); assert.match(await starting, /arriving \d{1,2}:\d{2}\./);
|
|
h.fix(37.705); assert.match(h.describeRouteStatus(), /ETA \d{1,2}:\d{2}\.$/);
|
|
h.setTimeFormat('12h'); assert.match(h.describeRouteStatus(), /ETA \d{1,2}:\d{2} [AP]M\.$/);
|
|
});
|
|
|
|
test('closing Navigate while a route request is pending cannot restart guidance or GPS', async () => {
|
|
const h = fixture(), release = h.holdRoute();
|
|
const starting = h.startNavigation('Test park', 'walking');
|
|
h.fix(37.7); await flush(); assert.equal(h.state().phase, 'routing');
|
|
h.send({ type: 'close-window', windowId: 'navigate:main' }); release();
|
|
await assert.rejects(starting, /Navigation cancelled/);
|
|
assert.equal(h.state().phase, 'idle'); assert.equal(h.tracker.running, false); assert.equal(h.timers.size, 0);
|
|
});
|
|
|
|
test('front page map entry follows location without routing, supports zoom and returns to destinations', async () => {
|
|
const h = fixture();
|
|
assert.equal(h.idleEntries()[0].label, 'Map around me');
|
|
assert.equal(h.idleEntries()[1].destination.name, 'Home');
|
|
h.input('click');
|
|
assert.equal(h.state().phase, 'acquiring');
|
|
assert.equal(h.tracker.running, true);
|
|
h.fix(37.7); await flush();
|
|
assert.equal(h.state().phase, 'map');
|
|
assert.deepEqual(h.requests, []);
|
|
// The map fills the window down to the footer hint, which rests on the bottom padding.
|
|
assert.equal(h.maps.at(-1).width, 576);
|
|
assert.equal(h.maps.at(-1).height, 452);
|
|
assert.equal(h.maps.at(-1).routePath, undefined);
|
|
assert.equal(h.maps.at(-1).camera.latitude, 37.7);
|
|
assert.equal(h.maps.at(-1).camera.bearingDeg, 0);
|
|
assert.match(h.describeRouteStatus(), /No destination/);
|
|
h.heading(90); assert.equal(h.state().headHeadingDeg, 107);
|
|
h.fix(37.705); await flush();
|
|
assert.equal(h.maps.at(-1).camera.latitude, 37.705);
|
|
const zoom = h.maps.at(-1).camera.zoom;
|
|
h.input('scroll-up'); await flush();
|
|
assert.equal(h.maps.at(-1).camera.zoom, zoom + 0.5);
|
|
h.input('click');
|
|
assert.equal(h.state().phase, 'idle');
|
|
assert.equal(h.tracker.running, false);
|
|
assert.equal(h.holds.at(-1), false);
|
|
assert.equal(h.timers.size, 0);
|
|
const count = h.maps.length;
|
|
h.send({ type: 'foreground', foreground: true, focused: true });
|
|
assert.equal(h.maps.length, count);
|
|
assert.deepEqual(h.errors, []);
|
|
});
|
|
|
|
test('map suspends fetching and compass while hidden and resizes to the viewport', async () => {
|
|
const h = fixture(), starting = h.startMap();
|
|
h.fix(37.7); await starting; await flush();
|
|
const count = h.maps.length;
|
|
h.send({ type: 'screen', on: false });
|
|
h.fix(37.71); h.tick(); await flush();
|
|
assert.equal(h.maps.length, count);
|
|
assert.equal(h.holds.at(-1), false);
|
|
h.send({ type: 'screen', on: true }); await flush();
|
|
assert.equal(h.maps.at(-1).camera.latitude, 37.71);
|
|
const resize = async viewport => { h.send({ type: 'resize-window', windowId: 'navigate:main', viewport }); await flush(); };
|
|
await resize(bordered(540, 260));
|
|
assert.equal(h.maps.at(-1).width, 540);
|
|
assert.equal(h.maps.at(-1).height, 232);
|
|
// With no border below, the footer hint moves down to the edge and the map follows it.
|
|
await resize(edged(540, 260, 'top', 'left'));
|
|
assert.equal(h.maps.at(-1).height, 240);
|
|
// A change to the other edges lays the window out again, but keeps the map it has.
|
|
const fetched = h.maps.length, painted = h.paints();
|
|
await resize(unbordered(540, 260));
|
|
assert.equal(h.maps.length, fetched);
|
|
assert.equal(h.paints(), painted + 1);
|
|
await resize(unbordered(540, 260));
|
|
assert.equal(h.paints(), painted + 1);
|
|
h.send({ type: 'close-window' });
|
|
assert.equal(h.tracker.running, false);
|
|
assert.equal(h.timers.size, 0);
|
|
assert.deepEqual(h.errors, []);
|
|
});
|
|
|
|
test('starting a destination from map mode switches to route guidance', async () => {
|
|
const h = fixture(), starting = h.startMap();
|
|
h.fix(37.7); await starting; await flush();
|
|
await h.startNavigation('Test park', 'walking'); await flush();
|
|
assert.equal(h.state().phase, 'navigating');
|
|
assert.deepEqual(h.requests, ['geocode', 'route']);
|
|
assert.equal(h.maps.at(-1).width, 260);
|
|
assert.ok(h.maps.at(-1).routePath.length >= 2);
|
|
assert.deepEqual(h.errors, []);
|
|
});
|
|
|
|
test('failed destination lookup keeps map mode and tracking active', async () => {
|
|
const h = fixture(), starting = h.startMap();
|
|
h.fix(37.7); await starting; await flush();
|
|
h.failRoute();
|
|
await assert.rejects(h.startNavigation('Test park', 'walking'), /Route unavailable/);
|
|
assert.equal(h.state().phase, 'map');
|
|
assert.equal(h.tracker.running, true);
|
|
h.fix(37.705); await flush();
|
|
assert.equal(h.maps.at(-1).routePath, undefined);
|
|
assert.match(h.describeRouteStatus(), /No destination/);
|
|
});
|
|
|
|
test('map requires a fresh fix and releases tracking when GPS times out', async () => {
|
|
const h = fixture(), starting = h.startMap();
|
|
h.send({ type: 'navigation-sensors', event: { kind: 'location', location: { ...fix(37.7), timestampMs: Date.now() - 120000 } } });
|
|
await flush();
|
|
assert.equal(h.state().phase, 'acquiring');
|
|
assert.equal(h.maps.length, 0);
|
|
h.expireFix(); await starting;
|
|
assert.equal(h.state().phase, 'idle');
|
|
assert.equal(h.tracker.running, false);
|
|
assert.equal(h.timers.size, 0);
|
|
});
|
|
|
|
test('closing map during GPS acquisition cannot reopen it on a late fix', async () => {
|
|
const h = fixture(), starting = h.startMap();
|
|
h.send({ type: 'close-window' });
|
|
h.fix(37.7); h.expireFix(); await starting;
|
|
assert.equal(h.state().phase, 'idle');
|
|
assert.equal(h.tracker.running, false);
|
|
assert.equal(h.maps.length, 0);
|
|
assert.equal(h.timers.size, 0);
|
|
});
|
|
|
|
for (const completion of ['resolve', 'reject']) {
|
|
test(`old map fetch ${completion} cannot overwrite a new mode or clear its pending fetch`, async () => {
|
|
const h = fixture(), oldMap = h.holdMap(), starting = h.startMap();
|
|
h.fix(37.7); await starting;
|
|
h.input('click');
|
|
const newMap = h.holdMap();
|
|
await h.startMap();
|
|
oldMap[completion](new Error('Old map failed')); await flush();
|
|
assert.equal(h.state().mapInFlight, true);
|
|
assert.equal(h.state().mapImage, null);
|
|
assert.equal(h.state().mapLastError, '');
|
|
newMap.resolve(); await flush();
|
|
assert.ok(h.state().mapImage);
|
|
assert.equal(h.state().mapInFlight, false);
|
|
});
|
|
}
|