banyaro/tests/js/test-map-offline-r4.js

// Runde-4-Tests: Minimal-Speicher-Modell (Prune, clear-behält-Zonen, Verify, Probe, Färbung)
const fs = require('fs');
const stores = { tiles: new Map(), meta: new Map() };
function mkReq(result) { return { result }; }
global.indexedDB = { open() {
  const req = {};
  setTimeout(() => {
    const db = {
      objectStoreNames: { contains: n => !!stores[n] },
      transaction(name) {
        const os = {
          get: k => mkReq(stores[name].get(k)),
          put: (v, k) => { stores[name].set(k, v); return mkReq(undefined); },
          delete: k => { stores[name].delete(k); return mkReq(undefined); },
          clear: () => { stores[name].clear(); return mkReq(undefined); },
          count: () => mkReq(stores[name].size),
          getAllKeys: () => mkReq([...stores[name].keys()]),
        };
        const tx = { objectStore: () => os };
        setTimeout(() => tx.oncomplete && tx.oncomplete());
        return tx;
      },
      close() {},
    };
    req.result = db; req.onsuccess && req.onsuccess();
  });
  return req;
} };
global.window = {};
Object.defineProperty(globalThis, 'navigator', { value: { onLine: true, storage: { persist: () => Promise.resolve(true) } }, configurable: true });
let tileFails = false;
global.pmtiles = { PMTiles: class { getZxy() { return tileFails ? Promise.reject(new Error('offline')) : Promise.resolve({ data: new Uint8Array(100).buffer }); } } };
global.MapGLStyle = { tilesUrl: () => 'http://t/d.pmtiles' };
let apiFails = false;
global.fetch = (url) => apiFails
  ? Promise.reject(new Error('offline'))
  : Promise.resolve({ ok: true, arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer), json: () => Promise.resolve([]) });
eval(fs.readFileSync(process.argv[2], 'utf8'));
const MO = global.window.MapOffline;
const sleep = ms => new Promise(r => setTimeout(r, ms));

(async () => {
  // 1. Ephemeres Vorausladen: Runde OHNE Funkloch → Prefetch wird gelöscht
  MO.setGps({ lat: 47.5, lon: 11.5 });
  await sleep(300);
  const afterPre = stores.tiles.size;
  if (!(afterPre > 0)) throw new Error('Prefetch lief nicht');
  MO.setGps(null);
  await sleep(300);
  console.log('Prune ohne Funkloch:', afterPre, '→', stores.tiles.size);
  if (stores.tiles.size !== 0) throw new Error('Prefetch nicht gepruned');

  // 2. Runde MIT Funkloch (Netz-Probe schlägt fehl) → Prefetch bleibt + Zone gemerkt
  MO.setGps({ lat: 47.5, lon: 11.5 });
  await sleep(300);
  tileFails = true;                                  // Funkloch: Tile-Remote-Miss bei aktivem GPS
  MO.setGps({ lat: 47.6, lon: 11.6 });
  await MO.tile(14, 1, 1);                           // nicht gespeichert + remote weg -> _noteRemoteMiss
  await sleep(300);
  tileFails = false;
  MO.setGps(null);
  await sleep(300);
  const zones1 = stores.meta.get('deadzones') || [];
  console.log('Nach Funkloch-Runde: tiles=', stores.tiles.size, 'zones=', zones1.length);
  if (!(stores.tiles.size > 0)) throw new Error('Prefetch trotz Funkloch gepruned');
  if (!(zones1.length >= 1)) throw new Error('Netz-Probe hat Funkloch nicht gemerkt');

  // 3. clear() behält Zonen (filled=false)
  stores.meta.get('deadzones').forEach(z => z.filled = true);
  stores.meta.set('deadzones', stores.meta.get('deadzones'));
  await MO.clear();
  const zones2 = stores.meta.get('deadzones') || [];
  console.log('Nach clear(): tiles=', stores.tiles.size, 'zones=', zones2.length, 'filled=', zones2.filter(z => z.filled).length);
  if (stores.tiles.size !== 0) throw new Error('clear löscht Kacheln nicht');
  if (!zones2.length || zones2.some(z => z.filled)) throw new Error('clear behält/reset Zonen nicht');

  // 4. autoFill mit Position: nahe Zone gefüllt (type funkloch), ferne (>50km) bleibt offen
  await MO.markDeadZone(49.9, 13.9);                 // ~270 km entfernt
  const n = await MO.autoFillDeadZones({ lat: 47.6, lon: 11.62 });
  const zones3 = stores.meta.get('deadzones');
  const near = zones3.find(z => Math.abs(z.lat - 47.6) < 0.2);
  const far  = zones3.find(z => z.lat === 49.9);
  console.log('autoFill nahe:', n, 'gefüllt; fern offen:', !far.filled);
  if (!near.filled || far.filled) throw new Error('Nähe-Filter kaputt');

  // 5. Verify: gefüllte Zone, Kacheln weg → wird beim nächsten autoFill neu geladen
  stores.tiles.clear();
  const n2 = await MO.autoFillDeadZones({ lat: 47.6, lon: 11.62 });
  console.log('Re-Fill nach Kachel-Verlust:', n2);
  if (n2 < 1) throw new Error('Coverage-Verify lädt nicht nach');

  // 6. Coverage-Färbung: funkloch-Kacheln markiert
  const gj = await MO.coverage();
  const fz = gj.features.filter(f => f.properties.kind === 'funkloch').length;
  console.log('Coverage:', gj.features.length, 'Features, davon funkloch:', fz);
  if (!(fz > 0)) throw new Error('Funkloch-Kacheln nicht markiert');

  console.log('\nALLE RUNDE-4-TESTS BESTANDEN');
})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });