malice

import assert from 'node:assert/strict';

import { test } from 'node:test';

import { isDismissed, recoveryPrompt, requestPersistence, setDismissed } from '../src/lib/protection-model.ts';

const state = (recovery: 'Unknown' | 'Disabled' | 'Incomplete' | 'Enabled') => ({

  device_id: 'D',

  device_verified: true,

  recovery,

  key_backup: 'Disabled'

});

const browser = { device: false, standalone: false };

const device = { device: true, standalone: false };

const installed = { device: true, standalone: true };

test('recovery prompt follows recovery state', () => {

  assert.equal(recoveryPrompt(null, device, false), null);

  assert.equal(recoveryPrompt(state('Unknown'), device, false), null);

  assert.equal(recoveryPrompt(state('Enabled'), device, false), null);

  assert.equal(recoveryPrompt(state('Incomplete'), device, true), 'recover');

  assert.equal(recoveryPrompt(state('Disabled'), device, false), 'setup');

});

test('only the device build in a browser tab may dismiss the setup prompt', () => {

  assert.equal(recoveryPrompt(state('Disabled'), device, true), null);

  assert.equal(recoveryPrompt(state('Disabled'), installed, true), 'setup');

  assert.equal(recoveryPrompt(state('Disabled'), browser, true), 'setup');

});

test('dismissals are per account', () => {

  const data = new Map<string, string>();

  const store = { getItem: (k: string) => data.get(k) ?? null, setItem: (k: string, v: string) => void data.set(k, v) };

  setDismissed(store, 'storage', '@a:x');

  assert.equal(isDismissed(store, 'storage', '@a:x'), true);

  assert.equal(isDismissed(store, 'storage', '@b:x'), false);

  assert.equal(isDismissed(store, 'recovery', '@a:x'), false);

});

test('persistence is requested only when not already granted', async () => {

  let asked = 0;

  const denied = {

    persisted: async () => false,

    persist: async () => (asked++, false),

    estimate: async () => ({ usage: 5, quota: 100 })

  };

  assert.deepEqual(await requestPersistence(denied), { persisted: false, usage: 5, quota: 100 });

  assert.equal(asked, 1);

  const granted = { persisted: async () => true, persist: async () => (asked++, true) };

  assert.deepEqual(await requestPersistence(granted), { persisted: true, usage: null, quota: null });

  assert.equal(asked, 1);

  assert.equal(await requestPersistence(undefined), null);

});