The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
// @vitest-environment jsdom
import type { UserDecision } from '@usercentrics/cmp-browser-sdk'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { applyPriorDecisionToSDK, consentState, detectPriorConsent } from './consent-state'
// jsdom's localStorage can be flaky in vitest, so ensure it's available
const storage = new Map<string, string>()
const mockLocalStorage = {
getItem: (key: string) => storage.get(key) ?? null,
setItem: (key: string, value: string) => storage.set(key, value),
removeItem: (key: string) => storage.delete(key),
clear: () => storage.clear(),
get length() {
return storage.size
},
key: (index: number) => Array.from(storage.keys())[index] ?? null,
}
beforeEach(() => {
storage.clear()
Object.defineProperty(globalThis, 'localStorage', {
value: mockLocalStorage,
writable: true,
configurable: true,
})
})
afterEach(() => {
storage.clear()
})
describe('detectPriorConsent', () => {
describe('scenario 1: GTM compressed format (ucData)', () => {
it('returns uniform-accept when every service has consent: true', () => {
storage.set(
'ucData',
JSON.stringify({
gcm: { adStorage: 'granted', analyticsStorage: 'granted' },
consent: {
services: {
svc1: { name: 'Google Analytics', consent: true },
svc2: { name: 'Stripe', consent: true },
svc3: { name: 'Sentry', consent: true },
},
},
})
)
expect(detectPriorConsent()).toEqual({ kind: 'uniform-accept' })
})
// Real customer data shape from GROWTH-790: essentials and functional
// services accepted, marketing/tracking services denied. This is what
// Opt out or a Privacy Settings toggle of the Marketing category produces
// in production — essentials are locked on and cannot actually be denied.
it('returns per-service decisions when ucData has a mixed consent state (GROWTH-790)', () => {
storage.set(
'ucData',
JSON.stringify({
gcm: {
adsDataRedaction: true,
adStorage: 'denied',
adPersonalization: 'denied',
adUserData: 'denied',
analyticsStorage: 'denied',
},
consent: {
services: {
J39GyuWQq: { name: 'Amazon Web Services', consent: true },
HkIVcNiuoZX: { name: 'Cloudflare', consent: true },
H1PKqNodoWQ: { name: 'Google AJAX', consent: true },
HkPBYFofN: { name: 'Google Fonts', consent: true },
QjO6LaiOd: { name: 'hCaptcha', consent: true },
'F-REmjGq7': { name: 'JSDelivr', consent: true },
Hko_qNsui_Q: { name: 'reCAPTCHA', consent: true },
rH1vNPCFR: { name: 'Sentry', consent: true },
ry3w9Vo_oZ7: { name: 'Stripe', consent: true },
BJTzqNi_i_m: { name: 'Twitter Plugin', consent: true },
HLap0udLC: { name: 'Twitter Syndication', consent: true },
H1Vl5NidjWX: { name: 'Usercentrics Consent Management Platform', consent: true },
BJz7qNsdj_7: { name: 'YouTube Video', consent: true },
S1_9Vsuj_Q: { name: 'Google Ads', consent: false },
HkocEodjb7: { name: 'Google Analytics', consent: false },
BJ59EidsWQ: { name: 'Google Tag Manager', consent: false },
nV4hGUA8RQK5Ez: { name: 'Supabase Event Tracking', consent: false },
},
},
})
)
const result = detectPriorConsent()
if (result === null || result.kind !== 'decisions') {
throw new Error(`expected decisions result, got ${JSON.stringify(result)}`)
}
expect(result.decisions).toHaveLength(17)
// Essentials / functional services preserved as accepted
expect(result.decisions).toContainEqual({ serviceId: 'J39GyuWQq', status: true })
expect(result.decisions).toContainEqual({ serviceId: 'rH1vNPCFR', status: true })
// Tracking services preserved as denied
expect(result.decisions).toContainEqual({ serviceId: 'S1_9Vsuj_Q', status: false })
expect(result.decisions).toContainEqual({ serviceId: 'HkocEodjb7', status: false })
expect(result.decisions).toContainEqual({ serviceId: 'BJ59EidsWQ', status: false })
expect(result.decisions).toContainEqual({ serviceId: 'nV4hGUA8RQK5Ez', status: false })
})
it('returns per-service decisions (all false) when every service was denied', () => {
storage.set(
'ucData',
JSON.stringify({
consent: {
services: {
svc1: { name: 'Google Analytics', consent: false },
svc2: { name: 'Stripe', consent: false },
},
},
})
)
expect(detectPriorConsent()).toEqual({
kind: 'decisions',
decisions: [
{ serviceId: 'svc1', status: false },
{ serviceId: 'svc2', status: false },
],
})
})
it('returns null when services object is empty', () => {
storage.set('ucData', JSON.stringify({ consent: { services: {} } }))
expect(detectPriorConsent()).toBeNull()
})
it('returns null when ucData is malformed JSON', () => {
storage.set('ucData', 'not-json')
expect(detectPriorConsent()).toBeNull()
})
it('returns null when ucData has no consent.services', () => {
storage.set('ucData', JSON.stringify({ gcm: {} }))
expect(detectPriorConsent()).toBeNull()
})
it('returns null when every service value is non-object', () => {
storage.set('ucData', JSON.stringify({ consent: { services: { svc1: 'not-an-object' } } }))
expect(detectPriorConsent()).toBeNull()
})
// Partial parse failures must fail closed. Cherry-picking the valid
// subset and calling it uniform-accept would let corrupted third-party
// storage silently upgrade a user's consent — the worst-direction bias
// in this domain.
it('returns null when any entry fails schema (fails closed on partial corruption)', () => {
storage.set(
'ucData',
JSON.stringify({
consent: {
services: {
svc1: 'not-an-object',
svc2: { name: 'Valid', consent: true },
},
},
})
)
expect(detectPriorConsent()).toBeNull()
})
})
describe('scenario 2: fast cross-app navigation (uc_settings gated by uc_user_interaction)', () => {
const buildUcSettings = (services: Array<{ id: string; status: boolean }>) =>
JSON.stringify({
controllerId: 'test-controller',
id: 'test-settings',
language: 'en',
services: services.map((s) => ({
id: s.id,
status: s.status,
processorId: 'test-processor',
history: [],
version: '1.0.0',
})),
version: '1.0.0',
})
it('returns uniform-accept when uc_settings has every service accepted', () => {
storage.set('uc_user_interaction', 'true')
storage.set(
'uc_settings',
buildUcSettings([
{ id: 'svc1', status: true },
{ id: 'svc2', status: true },
])
)
expect(detectPriorConsent()).toEqual({ kind: 'uniform-accept' })
})
it('returns per-service decisions when uc_settings has a mixed state', () => {
storage.set('uc_user_interaction', 'true')
storage.set(
'uc_settings',
buildUcSettings([
{ id: 'essential1', status: true },
{ id: 'tracking1', status: false },
{ id: 'tracking2', status: false },
])
)
const result = detectPriorConsent()
if (result === null || result.kind !== 'decisions') {
throw new Error(`expected decisions result, got ${JSON.stringify(result)}`)
}
expect(result.decisions).toHaveLength(3)
expect(result.decisions).toContainEqual({ serviceId: 'essential1', status: true })
expect(result.decisions).toContainEqual({ serviceId: 'tracking1', status: false })
expect(result.decisions).toContainEqual({ serviceId: 'tracking2', status: false })
})
it('returns null when uc_user_interaction is "true" but uc_settings is absent', () => {
storage.set('uc_user_interaction', 'true')
expect(detectPriorConsent()).toBeNull()
})
it('returns null when uc_settings is malformed JSON', () => {
storage.set('uc_user_interaction', 'true')
storage.set('uc_settings', 'not-json')
expect(detectPriorConsent()).toBeNull()
})
it('returns null when uc_settings services array is empty', () => {
storage.set('uc_user_interaction', 'true')
storage.set('uc_settings', buildUcSettings([]))
expect(detectPriorConsent()).toBeNull()
})
it('returns null when any uc_settings service entry fails schema', () => {
storage.set('uc_user_interaction', 'true')
storage.set(
'uc_settings',
JSON.stringify({
services: [
{ id: 'svc1', status: true, processorId: 'p', history: [], version: '1' },
{ id: 'svc2', status: 'not-a-boolean', processorId: 'p', history: [], version: '1' },
],
})
)
expect(detectPriorConsent()).toBeNull()
})
it('returns null when uc_user_interaction is "false" (even if uc_settings is valid)', () => {
storage.set('uc_user_interaction', 'false')
storage.set('uc_settings', buildUcSettings([{ id: 'svc1', status: true }]))
expect(detectPriorConsent()).toBeNull()
})
it('returns null when uc_user_interaction is absent', () => {
storage.set('uc_settings', buildUcSettings([{ id: 'svc1', status: true }]))
expect(detectPriorConsent()).toBeNull()
})
})
describe('combined scenarios', () => {
it('returns uniform-accept when ucData is fully accepted (ignoring uc_user_interaction/uc_settings)', () => {
storage.set(
'ucData',
JSON.stringify({
consent: { services: { svc1: { name: 'GA', consent: true } } },
})
)
storage.set('uc_user_interaction', 'true')
expect(detectPriorConsent()).toEqual({ kind: 'uniform-accept' })
})
it('prefers ucData decisions over uc_settings when both exist', () => {
storage.set(
'ucData',
JSON.stringify({
consent: { services: { svc1: { name: 'GA', consent: false } } },
})
)
storage.set('uc_user_interaction', 'true')
storage.set(
'uc_settings',
JSON.stringify({
services: [{ id: 'svc1', status: true, processorId: 'p', history: [], version: '1' }],
})
)
expect(detectPriorConsent()).toEqual({
kind: 'decisions',
decisions: [{ serviceId: 'svc1', status: false }],
})
})
it('falls back to uc_settings when ucData is corrupt (scenario 1 fails closed, scenario 2 recovers)', () => {
storage.set('ucData', JSON.stringify({ consent: { services: { svc1: 'corrupt' } } }))
storage.set('uc_user_interaction', 'true')
storage.set(
'uc_settings',
JSON.stringify({
services: [{ id: 'svc1', status: false, processorId: 'p', history: [], version: '1' }],
})
)
expect(detectPriorConsent()).toEqual({
kind: 'decisions',
decisions: [{ serviceId: 'svc1', status: false }],
})
})
it('returns null when localStorage is completely empty', () => {
expect(detectPriorConsent()).toBeNull()
})
})
})
describe('applyPriorDecisionToSDK', () => {
type MockService = { id: string; isEssential: boolean }
const makeMockUC = (
opts: {
services?: MockService[]
areAllAccepted?: boolean
onAcceptAll?: () => Promise<void>
onUpdateServices?: (decisions: UserDecision[]) => Promise<void>
} = {}
) => {
const services = opts.services ?? []
return {
acceptAllServices: vi.fn(opts.onAcceptAll ?? (() => Promise.resolve())),
denyAllServices: vi.fn(() => Promise.resolve()),
updateServices: vi.fn(opts.onUpdateServices ?? (() => Promise.resolve())),
getCategoriesBaseInfo: vi.fn(() => []),
getServicesBaseInfo: vi.fn(() => services),
areAllConsentsAccepted: vi.fn(() => opts.areAllAccepted ?? false),
}
}
beforeEach(() => {
consentState.UC = null
consentState.categories = null
consentState.showConsentToast = false
consentState.hasConsented = false
})
it('uniform-accept: calls acceptAllServices, sets hasConsented, suppresses banner', () => {
const UC = makeMockUC()
applyPriorDecisionToSDK(UC as never, { initialLayer: 0 }, { kind: 'uniform-accept' })
expect(UC.acceptAllServices).toHaveBeenCalledOnce()
expect(UC.updateServices).not.toHaveBeenCalled()
expect(consentState.hasConsented).toBe(true)
expect(consentState.showConsentToast).toBe(false)
})
it('decisions with full coverage: calls updateServices with stored decisions, suppresses banner', () => {
const UC = makeMockUC({
services: [
{ id: 'essential1', isEssential: true },
{ id: 'tracking1', isEssential: false },
{ id: 'tracking2', isEssential: false },
],
})
const decisions: UserDecision[] = [
{ serviceId: 'tracking1', status: true },
{ serviceId: 'tracking2', status: false },
]
applyPriorDecisionToSDK(UC as never, { initialLayer: 0 }, { kind: 'decisions', decisions })
expect(UC.updateServices).toHaveBeenCalledWith(decisions)
expect(UC.acceptAllServices).not.toHaveBeenCalled()
expect(consentState.showConsentToast).toBe(false)
})
// GROWTH-790 compliance guard: when the ruleset adds a new non-essential
// service after the user's stored decisions were written, we must NOT
// silently restore — the user has never seen this service and can't have
// consented to it. Show the banner instead.
it('decisions with uncovered non-essential service: shows banner, does not mutate SDK', () => {
const UC = makeMockUC({
services: [
{ id: 'tracking1', isEssential: false },
{ id: 'tracking_new', isEssential: false }, // in ruleset, not in decisions
],
})
applyPriorDecisionToSDK(
UC as never,
{ initialLayer: 0 },
{ kind: 'decisions', decisions: [{ serviceId: 'tracking1', status: false }] }
)
expect(UC.updateServices).not.toHaveBeenCalled()
expect(UC.acceptAllServices).not.toHaveBeenCalled()
expect(consentState.showConsentToast).toBe(true)
})
// Essentials are SDK-forced-on regardless of user decision, so a new
// essential service appearing since the stored decisions were written
// should not trigger a re-prompt — the user has nothing meaningful to
// decide about it.
it('decisions covering only non-essentials: still restores (essentials ignored in coverage check)', () => {
const UC = makeMockUC({
services: [
{ id: 'essential_new', isEssential: true }, // not in decisions, but essential
{ id: 'tracking1', isEssential: false },
],
})
applyPriorDecisionToSDK(
UC as never,
{ initialLayer: 0 },
{ kind: 'decisions', decisions: [{ serviceId: 'tracking1', status: false }] }
)
expect(UC.updateServices).toHaveBeenCalledOnce()
expect(consentState.showConsentToast).toBe(false)
})
it('null prior decision: shows banner at default', () => {
const UC = makeMockUC()
applyPriorDecisionToSDK(UC as never, { initialLayer: 0 }, null)
expect(UC.updateServices).not.toHaveBeenCalled()
expect(UC.acceptAllServices).not.toHaveBeenCalled()
expect(consentState.showConsentToast).toBe(true)
})
it('SDK not requesting first-layer banner: no restore attempted even if priorDecision exists', () => {
const UC = makeMockUC({ areAllAccepted: true })
applyPriorDecisionToSDK(UC as never, { initialLayer: 1 }, { kind: 'uniform-accept' })
expect(UC.acceptAllServices).not.toHaveBeenCalled()
expect(UC.updateServices).not.toHaveBeenCalled()
expect(consentState.hasConsented).toBe(true)
expect(consentState.showConsentToast).toBe(false)
})
it('SDK already considers user consented: passes through, no restore', () => {
const UC = makeMockUC({ areAllAccepted: true })
applyPriorDecisionToSDK(
UC as never,
{ initialLayer: 0 },
{
kind: 'decisions',
decisions: [{ serviceId: 'svc1', status: false }],
}
)
expect(UC.updateServices).not.toHaveBeenCalled()
expect(consentState.hasConsented).toBe(true)
})
})