tilbudgivern/backend/__tests__/siteGeometryPersistence.test.js

const { SiteGeometryService } = require('../src/services/siteGeometryService');
const polygon = { geometry: { type: 'Polygon', coordinates: [[[10,56],[10.001,56],[10.001,56.001],[10,56]]] } };
function database() {
  let row; let events = []; let tail = Promise.resolve();
  const execute = async (sql, args) => {
    if (sql.startsWith('SELECT id')) return [[{ id: 7 }]];
    if (sql.startsWith('SELECT')) return [row ? [row] : []];
    if (sql.startsWith('INSERT INTO project_site_geometry_audit')) { events.push(args); return [{}]; }
    if (sql.startsWith('INSERT INTO project_site_geometry ')) { row = { revision: args[1], geometry_json: args[2] }; return [{}]; }
    throw new Error(sql);
  };
  return { events, query: async (...args) => (await execute(...args))[0], pool: { getConnection: async () => {
    let release;
    return { execute, beginTransaction: async () => { const prior = tail; tail = new Promise(r => { release=r; }); await prior; }, commit: async () => release(), rollback: async () => release(), release: () => {} };
  } } };
}
test('serializes simultaneous initial writes, reads authoritative revision and audits operator', async () => {
  const db = database(); const service = new SiteGeometryService(db);
  expect(await service.get(7)).toBeNull();
  const results = await Promise.allSettled(['alex','other'].map(operator => service.save(7, { ...polygon, expectedRevision: 0 }, operator)));
  expect(results.filter(r => r.status === 'fulfilled')).toHaveLength(1);
  expect(results.find(r => r.status === 'rejected').reason).toMatchObject({ status: 409, code: 'GEOMETRY_REVISION_CONFLICT' });
  const saved = await service.get(7);
  expect(saved).toMatchObject({ revision: 1, audit: { createdBy: 'alex', updatedBy: 'alex' } });
  const next = await service.save(7, { ...polygon, expectedRevision: 1 }, 'alex');
  expect(next.revision).toBe(2);
  expect(db.events).toHaveLength(2);
  expect(next.signature).not.toBe(saved.signature);
});
test('requires explicit valid revision and operator', async () => {
  const service = new SiteGeometryService(database());
  await expect(service.save(7, polygon, 'alex')).rejects.toMatchObject({ status: 400 });
  await expect(service.save(7, { ...polygon, expectedRevision: 0 }, '')).rejects.toMatchObject({ status: 400 });
});

test('deletes with optimistic concurrency, retains a revision tombstone and appends audit evidence', async () => {
  const db = database();
  const service = new SiteGeometryService(db);
  const saved = await service.save(7, { ...polygon, expectedRevision: 0 }, 'alex');

  const deleted = await service.delete(7, { expectedRevision: saved.revision }, 'alex');

  expect(deleted).toMatchObject({ geometry: null, revision: 2, deleted: true });
  expect(await service.get(7)).toBeNull();
  expect(await service.getState(7)).toMatchObject({ geometry: null, revision: 2 });
  expect(db.events).toHaveLength(2);
  expect(db.events[1]).toEqual(expect.arrayContaining([
    7, 2, 'alex', 'deleted', expect.any(Date), saved.signature, expect.any(String), expect.any(String)
  ]));
  const tombstone = JSON.parse(db.events[1][7]);
  expect(tombstone).toMatchObject({ schema: 'site_geometry_tombstone_v1', revision: 2, deleted: true });
  expect(tombstone.signature).toBe(db.events[1][6]);
});

test('refuses absent and stale deletion without appending evidence or changing geometry', async () => {
  const db = database();
  const service = new SiteGeometryService(db);
  await expect(service.delete(7, { expectedRevision: 0 }, 'alex')).rejects.toMatchObject({
    status: 404, code: 'SITE_GEOMETRY_NOT_FOUND'
  });
  expect(db.events).toHaveLength(0);

  const saved = await service.save(7, { ...polygon, expectedRevision: 0 }, 'alex');
  await expect(service.delete(7, { expectedRevision: 0 }, 'alex')).rejects.toMatchObject({
    status: 409, code: 'GEOMETRY_REVISION_CONFLICT'
  });
  expect(await service.get(7)).toEqual(saved);
  expect(db.events).toHaveLength(1);
});

test('requires deletion revision and operator and restores only from the tombstone revision', async () => {
  const db = database();
  const service = new SiteGeometryService(db);
  const saved = await service.save(7, { ...polygon, expectedRevision: 0 }, 'alex');
  await expect(service.delete(7, {}, 'alex')).rejects.toMatchObject({ status: 400 });
  await expect(service.delete(7, { expectedRevision: saved.revision }, '')).rejects.toMatchObject({ status: 400 });
  const deleted = await service.delete(7, { expectedRevision: saved.revision }, 'alex');
  await expect(service.save(7, { ...polygon, expectedRevision: 0 }, 'alex')).rejects.toMatchObject({ status: 409 });
  const restored = await service.save(7, { ...polygon, expectedRevision: deleted.revision }, 'alex');
  expect(restored.revision).toBe(3);
  expect(db.events[2][3]).toBe('restored');
});

test('runtime migration installs dedicated canonical and audit tables', async () => {
  const { migrateSiteGeometry } = require('../src/services/siteGeometryMigration');
  const db = { query: jest.fn().mockResolvedValue([]) };
  await migrateSiteGeometry(db);
  expect(db.query.mock.calls.map(c => c[0]).join('\n')).toMatch(/CREATE TABLE IF NOT EXISTS project_site_geometry /);
  expect(db.query.mock.calls.map(c => c[0]).join('\n')).toMatch(/CREATE TABLE IF NOT EXISTS project_site_geometry_audit /);
});

test('runtime migration skips task geometry basis when the task table is not installed yet', async () => {
  const { migrateSiteGeometry } = require('../src/services/siteGeometryMigration');
  const db = {
    query: jest.fn(async sql => {
      if (/INFORMATION_SCHEMA\.TABLES/.test(sql)) return [];
      if (/ALTER TABLE smart_package_tasks/.test(sql)) {
        throw new Error('must not alter a missing table');
      }
      return [];
    })
  };

  await expect(migrateSiteGeometry(db)).resolves.toBeUndefined();
  expect(db.query.mock.calls.map(call => call[0]).join('\n')).not.toMatch(/ALTER TABLE smart_package_tasks/);
});

test('runtime migration installs durable global geocoder gate and expiring cache', async () => {
  const { migrateSiteGeometry } = require('../src/services/siteGeometryMigration');
  const db = {
    query: jest.fn(async sql => (
      /INFORMATION_SCHEMA\.TABLES/.test(sql) ? [{ exists: 1 }] : []
    ))
  };
  await migrateSiteGeometry(db);
  const sql = db.query.mock.calls.map(c => c[0]).join('\n');
  expect(sql).toMatch(/CREATE TABLE IF NOT EXISTS nominatim_rate_gate/);
  expect(sql).toMatch(/next_request_at DATETIME\(6\) NOT NULL/);
  expect(sql).toMatch(/reservation_token CHAR\(64\) NULL/);
  expect(sql).toMatch(/reservation_expires_at DATETIME\(6\) NULL/);
  expect(sql).toMatch(/INSERT IGNORE INTO nominatim_rate_gate/);
  expect(sql).toMatch(/CREATE TABLE IF NOT EXISTS nominatim_cache/);
  expect(sql).toMatch(/query_key VARBINARY\(800\) PRIMARY KEY/);
  expect(sql).toMatch(/results_json JSON NOT NULL/);
  expect(sql).toMatch(/expires_at DATETIME\(6\) NOT NULL/);
  expect(sql).toMatch(/INDEX cache_expiry \(expires_at\)/);
  expect(sql).toMatch(/ALTER TABLE smart_package_tasks/);
  expect(sql).toMatch(/ADD COLUMN IF NOT EXISTS geometry_basis VARCHAR\(50\) NULL/);
});