@learncard/partner-connect 0.3.10 → 0.4.1

package/src/mock-mode.test.ts

@@ -0,0 +1,478 @@
+/**
+ * Tests for standalone mock mode and embed detection in
+ * @learncard/partner-connect. These run in jsdom, where `window.self` equals
+ * `window.top` (i.e. not embedded), so 'auto' mock mode is active by default.
+ */
+
+import { PartnerConnect, createPartnerConnect, isEmbedded } from './index';
+
+const flush = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+let errorSpy: jest.SpyInstance;
+
+beforeEach(() => {
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    try {
+        localStorage.clear();
+    } catch {
+        // localStorage may be unavailable in some environments.
+    }
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+    document.querySelectorAll('.lc-mock-toast, .lc-mock-stack').forEach(node => node.remove());
+});
+
+describe('isEmbedded', () => {
+    it('returns false at the top level (jsdom is not embedded)', () => {
+        expect(isEmbedded()).toBe(false);
+        expect(PartnerConnect.isEmbedded()).toBe(false);
+        expect(createPartnerConnect().isEmbedded()).toBe(false);
+    });
+
+    it('returns true when window.self differs from window.top', () => {
+        const originalTop = Object.getOwnPropertyDescriptor(window, 'top');
+        Object.defineProperty(window, 'top', {
+            configurable: true,
+            get: () => ({} as Window),
+        });
+
+        try {
+            expect(isEmbedded()).toBe(true);
+        } finally {
+            if (originalTop) Object.defineProperty(window, 'top', originalTop);
+        }
+    });
+});
+
+describe('standalone with no host (not embedded, not mocking)', () => {
+    it('fails fast with LC_NOT_EMBEDDED instead of timing out', async () => {
+        const lc = createPartnerConnect({ mock: false });
+        await expect(lc.requestIdentity()).rejects.toMatchObject({ code: 'LC_NOT_EMBEDDED' });
+    });
+
+    it('logs an actionable breadcrumb once, not per call', async () => {
+        const lc = createPartnerConnect({ mock: false });
+        await lc.requestIdentity().catch(() => undefined);
+        await lc.getSyncStatus().catch(() => undefined);
+        await lc.incrementCounter('coins', 1).catch(() => undefined);
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('mock mode activation', () => {
+    it('auto-activates when not embedded', () => {
+        expect(createPartnerConnect().isMocked()).toBe(true);
+    });
+
+    it('can be forced off', () => {
+        expect(createPartnerConnect({ mock: false }).isMocked()).toBe(false);
+    });
+
+    it('can be forced on', () => {
+        expect(createPartnerConnect({ mock: true }).isMocked()).toBe(true);
+    });
+
+    it('does NOT auto-mock on non-local standalone hosts (deploy previews, production)', async () => {
+        const original = Object.getOwnPropertyDescriptor(window, 'location');
+        Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: {
+                hostname: 'my-app.netlify.app',
+                search: '',
+                href: 'https://my-app.netlify.app/',
+            },
+        });
+
+        try {
+            const lc = createPartnerConnect();
+            expect(lc.isMocked()).toBe(false);
+            await expect(lc.requestIdentity()).rejects.toMatchObject({
+                code: 'LC_NOT_EMBEDDED',
+            });
+
+            expect(createPartnerConnect({ mock: true }).isMocked()).toBe(true);
+            expect(createPartnerConnect({ mock: 'standalone' }).isMocked()).toBe(true);
+        } finally {
+            if (original) Object.defineProperty(window, 'location', original);
+        }
+    });
+
+    it('auto-mocks on *.local and *.localhost dev hosts', () => {
+        const original = Object.getOwnPropertyDescriptor(window, 'location');
+
+        for (const hostname of ['myapp.local', 'myapp.localhost']) {
+            Object.defineProperty(window, 'location', {
+                configurable: true,
+                value: { hostname, search: '', href: `http://${hostname}/` },
+            });
+
+            try {
+                expect(createPartnerConnect().isMocked()).toBe(true);
+            } finally {
+                if (original) Object.defineProperty(window, 'location', original);
+            }
+        }
+    });
+});
+
+describe('embedded parent classification', () => {
+    let originalTop: PropertyDescriptor | undefined;
+    let originalLocation: PropertyDescriptor | undefined;
+
+    const embedIn = (ancestorOrigin: string | null, hostname = 'localhost'): void => {
+        Object.defineProperty(window, 'top', {
+            configurable: true,
+            get: () => ({} as Window),
+        });
+        Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: {
+                hostname,
+                search: '',
+                href: `http://${hostname}/`,
+                ...(ancestorOrigin ? { ancestorOrigins: [ancestorOrigin] } : {}),
+            },
+        });
+    };
+
+    beforeEach(() => {
+        originalTop = Object.getOwnPropertyDescriptor(window, 'top');
+        originalLocation = Object.getOwnPropertyDescriptor(window, 'location');
+    });
+
+    afterEach(() => {
+        if (originalTop) Object.defineProperty(window, 'top', originalTop);
+        if (originalLocation) Object.defineProperty(window, 'location', originalLocation);
+    });
+
+    it('never mocks when the parent is a configured LearnCard origin', () => {
+        embedIn('https://learncard.app');
+        expect(createPartnerConnect().isMocked()).toBe(false);
+    });
+
+    it('auto-mocks immediately inside a foreign (non-LearnCard) iframe on a local dev host', () => {
+        embedIn('https://storybook.example.com');
+        expect(createPartnerConnect().isMocked()).toBe(true);
+    });
+
+    it('fails fast instead of hanging inside a foreign iframe when mocking is off', async () => {
+        embedIn('https://storybook.example.com');
+        const lc = createPartnerConnect({ mock: false });
+        await expect(lc.requestIdentity()).rejects.toMatchObject({ code: 'LC_NOT_EMBEDDED' });
+    });
+
+    it('probes an ambiguous localhost parent and mocks when nothing answers', async () => {
+        embedIn('http://localhost:6006');
+        const lc = createPartnerConnect({ hostProbeTimeout: 40 });
+        expect(lc.isMocked()).toBe(false);
+
+        const identity = await lc.requestIdentity();
+        expect(lc.isMocked()).toBe(true);
+        expect(identity.user.did).toBeDefined();
+    });
+
+    it("mock: 'standalone' mocks inside a foreign iframe even on a non-local host", () => {
+        embedIn('https://preview-shell.example.com', 'my-app.lovable.app');
+        expect(createPartnerConnect({ mock: 'standalone' }).isMocked()).toBe(true);
+    });
+
+    it("mock: 'standalone' uses the real host when embedded in a LearnCard origin", () => {
+        embedIn('https://learncard.app', 'my-app.lovable.app');
+        expect(createPartnerConnect({ mock: 'standalone' }).isMocked()).toBe(false);
+    });
+
+    it("mock: 'standalone' probes an ambiguous parent on non-local hosts and mocks when unanswered", async () => {
+        embedIn('http://localhost:6006', 'my-app.lovable.app');
+        const lc = createPartnerConnect({ mock: 'standalone', hostProbeTimeout: 40 });
+
+        const identity = await lc.requestIdentity();
+        expect(lc.isMocked()).toBe(true);
+        expect(identity.user.did).toBeDefined();
+    });
+
+    it('stays in real-host mode when the probe is answered', async () => {
+        embedIn('http://localhost');
+
+        const answerProbe = (event: MessageEvent): void => {
+            const data = event.data as { action?: string; requestId?: string; protocol?: string };
+            if (data?.action !== 'GET_SYNC_STATUS' || !data.requestId) return;
+            window.postMessage(
+                {
+                    protocol: data.protocol,
+                    requestId: data.requestId,
+                    type: 'SUCCESS',
+                    data: { status: 'ready' },
+                },
+                'http://localhost'
+            );
+        };
+        window.addEventListener('message', answerProbe);
+
+        try {
+            const lc = createPartnerConnect({ hostProbeTimeout: 500 });
+            await new Promise(resolve => setTimeout(resolve, 100));
+            expect(lc.isMocked()).toBe(false);
+        } finally {
+            window.removeEventListener('message', answerProbe);
+        }
+    });
+});
+
+describe('mock responses', () => {
+    it('resolves requestIdentity with the configured fake DID', async () => {
+        const lc = createPartnerConnect({ mockOptions: { did: 'did:web:test:me', ui: false } });
+        const identity = await lc.requestIdentity();
+        expect(identity.token).toContain('mock-token');
+        expect(identity.user.did).toBe('did:web:test:me');
+    });
+
+    it('resolves raw sendCredential with a mock credential id', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        const res = (await lc.sendCredential({
+            credentialSubject: { achievement: { name: 'Course Completion' } },
+        })) as { credentialId: string };
+        expect(res.credentialId).toContain('mock-credential');
+    });
+
+    it('resolves template sendCredential with mock URIs', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        const res = (await lc.sendCredential({ templateAlias: 'course-completion' })) as {
+            credentialUri: string;
+            boostUri: string;
+        };
+        expect(res.credentialUri).toContain('lc:mock:credential');
+        expect(res.boostUri).toContain('course-completion');
+    });
+
+    it('auto-grants requestConsent', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await expect(lc.requestConsent('lc:contract:abc')).resolves.toEqual({ granted: true });
+    });
+
+    it('reports a ready sync status so onSyncComplete resolves', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await expect(lc.getSyncStatus()).resolves.toMatchObject({ status: 'ready' });
+    });
+});
+
+describe('mock counters', () => {
+    it('increments, reads, and persists counters', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+
+        const first = await lc.incrementCounter('coins', 10);
+        expect(first).toEqual({ key: 'coins', previousValue: 0, newValue: 10 });
+
+        const second = await lc.incrementCounter('coins', -3);
+        expect(second.newValue).toBe(7);
+
+        const read = await lc.getCounter('coins');
+        expect(read.value).toBe(7);
+        expect(read.updatedAt).not.toBeNull();
+
+        const all = await lc.getCounters(['coins']);
+        expect(all.counters[0]).toMatchObject({ key: 'coins', value: 7 });
+    });
+
+    it('persists counters across instances via localStorage', async () => {
+        const a = createPartnerConnect({ mockOptions: { ui: false } });
+        await a.incrementCounter('spins', 5);
+
+        const b = createPartnerConnect({ mockOptions: { ui: false } });
+        const read = await b.getCounter('spins');
+        expect(read.value).toBe(5);
+    });
+});
+
+describe('mock coherence (reads reflect this session writes)', () => {
+    it('checkUserHasCredential reflects a template credential issued this session', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+
+        const before = await lc.checkUserHasCredential({ templateAlias: 'algebra' });
+        expect(before.hasCredential).toBe(false);
+
+        await lc.sendCredential({ templateAlias: 'algebra' });
+
+        const after = await lc.checkUserHasCredential({ templateAlias: 'algebra' });
+        expect(after.hasCredential).toBe(true);
+        expect(after.credentialUri).toBeDefined();
+    });
+
+    it('learner context and credential search include issued credentials', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await lc.sendCredential({ templateAlias: 'algebra' });
+
+        const context = await lc.requestLearnerContext({ format: 'structured' });
+        expect(context.raw?.credentials.length).toBe(1);
+
+        const search = await lc.askCredentialSearch({ query: [], challenge: 'c', domain: 'd' });
+        expect(search.verifiablePresentation?.verifiableCredential.length).toBe(1);
+    });
+
+    it('learner context omits raw data unless format is structured', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await lc.sendCredential({ templateAlias: 'algebra' });
+
+        const context = await lc.requestLearnerContext();
+        expect(context.raw).toBeUndefined();
+        expect(context.prompt).toContain('algebra');
+    });
+
+    it('learner context respects includeCredentials: false', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await lc.sendCredential({
+            templateAlias: 'algebra',
+            templateData: { name: 'Algebra 101' },
+        });
+
+        const context = await lc.requestLearnerContext({
+            includeCredentials: false,
+            format: 'structured',
+        });
+        expect(context.raw?.credentials.length).toBe(0);
+        expect(context.prompt).not.toContain('Algebra 101');
+    });
+
+    it('AI sessions reuse one topic: first call creates it, later calls report isNewTopic false', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        const summaryData = {
+            title: 'Session',
+            summary: 'Mock summary',
+            learned: [],
+            nextSteps: [],
+            reflections: [],
+            skills: [],
+        };
+
+        const first = await lc.sendAiSessionCredential({ sessionTitle: 'One', summaryData });
+        expect(first.isNewTopic).toBe(true);
+        expect(first.topicCredentialUri).toBeDefined();
+
+        const second = await lc.sendAiSessionCredential({ sessionTitle: 'Two', summaryData });
+        expect(second.isNewTopic).toBe(false);
+        expect(second.topicUri).toBe(first.topicUri);
+        expect(second.topicCredentialUri).toBeUndefined();
+        expect(second.sessionCredentialUri).not.toBe(first.sessionCredentialUri);
+    });
+
+    it('preventDuplicateClaim returns the existing credential', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        const first = (await lc.sendCredential({
+            templateAlias: 'algebra',
+            preventDuplicateClaim: true,
+        })) as { credentialUri: string };
+        const second = (await lc.sendCredential({
+            templateAlias: 'algebra',
+            preventDuplicateClaim: true,
+        })) as { credentialUri: string; alreadyClaimed?: boolean };
+
+        expect(second.alreadyClaimed).toBe(true);
+        expect(second.credentialUri).toBe(first.credentialUri);
+    });
+
+    it('initiateTemplateIssue populates recipients and issuance status', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false } });
+        await lc.initiateTemplateIssue('boost-xyz', ['alice', 'bob']);
+
+        const recipients = await lc.getTemplateRecipients({ boostUri: 'boost-xyz' });
+        expect(recipients.total).toBe(2);
+
+        const status = await lc.getTemplateIssuanceStatus({
+            boostUri: 'boost-xyz',
+            recipient: 'alice',
+        });
+        expect(status.sent).toBe(true);
+        expect(status.status).toBe('pending');
+    });
+});
+
+describe('mock seeding', () => {
+    it('seeds identity did returned by requestIdentity', async () => {
+        const lc = createPartnerConnect({
+            mockOptions: { ui: false, identity: { did: 'did:web:seed:me', name: 'Ada' } },
+        });
+        const identity = await lc.requestIdentity();
+        expect(identity.user.did).toBe('did:web:seed:me');
+        expect((identity.user as { name?: string }).name).toBe('Ada');
+    });
+
+    it('seeds held credentials so happy-path reads work immediately', async () => {
+        const lc = createPartnerConnect({
+            mockOptions: {
+                ui: false,
+                credentials: [{ templateAlias: 'algebra', name: 'Algebra 101' }],
+            },
+        });
+        const check = await lc.checkUserHasCredential({ templateAlias: 'algebra' });
+        expect(check.hasCredential).toBe(true);
+    });
+
+    it('seeds initial counter values', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: false, counters: { coins: 50 } } });
+        const { value } = await lc.getCounter('coins');
+        expect(value).toBe(50);
+    });
+});
+
+describe('mock UI', () => {
+    const toastCount = (): number => document.querySelectorAll('.lc-mock-toast').length;
+    const toastText = (): string =>
+        Array.from(document.querySelectorAll('.lc-mock-toast'))
+            .map(n => n.textContent ?? '')
+            .join('\n');
+
+    it('renders a claim toast for sendCredential when ui is enabled', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: true } });
+        await lc.sendCredential({ templateAlias: 'badge' });
+        await flush();
+        expect(toastCount()).toBe(1);
+    });
+
+    it('renders a positive-tone toast for requestConsent', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: true } });
+        await lc.requestConsent();
+        await flush();
+        expect(document.querySelector('.lc-mock-toast--positive')).not.toBeNull();
+    });
+
+    it('surfaces a toast for every mocked action (not just console)', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: true } });
+
+        await lc.requestIdentity();
+        await lc.launchFeature('/wallet');
+        await lc.askCredentialSearch({ query: [], challenge: 'c', domain: 'd' });
+        await lc.askCredentialSpecific('id');
+        await lc.initiateTemplateIssue('boost');
+        await lc.requestLearnerContext();
+        await lc.getSyncStatus();
+        await lc.checkUserHasCredential({ templateAlias: 't' });
+        await lc.getTemplateIssuanceStatus({ templateAlias: 't', recipient: 'r' });
+        await lc.getTemplateRecipients({ templateAlias: 't' });
+        await lc.sendNotification({ title: 'Hi' });
+        await lc.getCounter('coins');
+        await flush();
+
+        expect(toastCount()).toBe(12);
+        expect(toastText()).toContain('/wallet');
+    });
+
+    it('coalesces identical repeated toasts into one with a count', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: true } });
+        await lc.getSyncStatus();
+        await lc.getSyncStatus();
+        await lc.getSyncStatus();
+        await flush();
+        expect(toastCount()).toBe(1);
+        expect(toastText()).toContain('×3');
+    });
+
+    it('cleans up injected DOM on destroy', async () => {
+        const lc = createPartnerConnect({ mockOptions: { ui: true } });
+        await lc.requestConsent();
+        await flush();
+        lc.destroy();
+        expect(toastCount()).toBe(0);
+    });
+});

package/src/types.ts

@@ -100,6 +100,163 @@ export interface PartnerConnectOptions {
      * Request timeout in milliseconds (default: 30000)
      */
     requestTimeout?: number;
+
+    /**
+     * Controls automatic **standalone mock mode**.
+     *
+     * When the SDK runs outside of a LearnCard host (i.e. as a top-level page,
+     * not embedded in an iframe), there is no host to answer `postMessage`
+     * requests, so every call would hang until it times out. Mock mode makes
+     * the SDK simulate the host locally so your app is fully buildable,
+     * demo-able, and testable without being embedded — and then behaves
+     * identically (real host) once embedded, with no code changes.
+     *
+     * - `'auto'` **(default)**: mock only when **no LearnCard host is present
+     *    AND the app is running on a local dev host** (`localhost`,
+     *    `127.0.0.1`, `[::1]`, `*.localhost`, `*.local`). This covers local
+     *    dev and local Storybook, but deliberately never fabricates identity
+     *    or consent on a production or preview origin. Each mocked call
+     *    surfaces a labeled toast plus a console log so it's clear the host
+     *    is simulated.
+     * - `'standalone'`: mock whenever **no LearnCard host is present**, on
+     *    any origin — including remote deploy previews (Netlify, Lovable,
+     *    Vercel, …) — and use the real host when embedded in LearnCard. The
+     *    one-flag setting for apps that must demo standalone anywhere. Only
+     *    choose it when a user opening your app's URL directly should see
+     *    simulated data.
+     * - `true`: always mock, **even when embedded in a real LearnCard host**.
+     *    Use this for CI and tests; for previews that should go real once
+     *    embedded, prefer `'standalone'`.
+     * - `false`: never mock. Standalone calls reject immediately with
+     *    `LC_NOT_EMBEDDED`. Set this in production builds meant to run only
+     *    inside LearnCard.
+     *
+     * @default 'auto'
+     */
+    mock?: boolean | 'auto' | 'standalone';
+
+    /**
+     * Fine-grained configuration for standalone mock mode. Ignored when mock
+     * mode is not active. See {@link MockHostOptions}.
+     */
+    mockOptions?: MockHostOptions;
+
+    /**
+     * How long (ms) to wait for the host to answer the one-time presence
+     * probe used when the SDK is embedded in an iframe whose parent cannot
+     * be confirmed as LearnCard (e.g. a same-origin Storybook canvas on
+     * localhost). Only used with `mock: 'auto'` on local dev hosts.
+     *
+     * @default 1500
+     */
+    hostProbeTimeout?: number;
+}
+
+/**
+ * Options controlling the behavior of standalone mock mode.
+ *
+ * All fields are optional; mock mode works out-of-the-box with sensible
+ * defaults (visible UI, console logging, and localStorage-backed counters).
+ */
+export interface MockHostOptions {
+    /**
+     * Render lightweight visual feedback in the page: a fake credential-claim
+     * modal / toast for `sendCredential`, and a "mock consent" banner for
+     * `requestConsent`. Set to `false` for a headless mock (logs only).
+     *
+     * @default true
+     */
+    ui?: boolean;
+
+    /**
+     * Log every simulated host interaction to the console with a clear
+     * `[LearnCard SDK · MOCK]` prefix.
+     *
+     * @default true
+     */
+    log?: boolean;
+
+    /**
+     * Persist counters (`incrementCounter` / `getCounter` / `getCounters`) to
+     * `localStorage` so values survive page reloads, mirroring the real host's
+     * durable per-user counters. Falls back to in-memory storage when
+     * `localStorage` is unavailable.
+     *
+     * @default true
+     */
+    persist?: boolean;
+
+    /**
+     * The fake DID returned by `requestIdentity()` (and used as the mock
+     * user's identity) while in mock mode.
+     *
+     * @default 'did:web:mock.learncard.app:user'
+     */
+    did?: string;
+
+    /**
+     * Namespace used to scope persisted mock data (counters, claimed
+     * credentials) in `localStorage`. Change this if you run multiple mock
+     * apps on the same origin and want isolated state.
+     *
+     * @default 'lc-mock'
+     */
+    namespace?: string;
+
+    /**
+     * Seed the mock user's identity. Superseded per-field over the legacy
+     * `did` option. Extra fields are returned as-is from `requestIdentity()`.
+     */
+    identity?: MockIdentitySeed;
+
+    /**
+     * Pre-populate the mock with credentials the user already holds (or has
+     * issued to others). This lets you demo "happy path" states — e.g. a
+     * "you already earned this" banner — without performing an action first.
+     * Reads like `checkUserHasCredential`, `getTemplateRecipients`,
+     * `requestLearnerContext`, and `askCredentialSearch` reflect these.
+     */
+    credentials?: MockCredentialSeed[];
+
+    /**
+     * Initial counter values, applied only when a counter has no persisted
+     * value yet (so incremented values survive reloads).
+     */
+    counters?: Record<string, number>;
+}
+
+/**
+ * Seed shape for the mock user's identity (see {@link MockHostOptions.identity}).
+ */
+export interface MockIdentitySeed {
+    did?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * Seed shape for a pre-populated mock credential (see
+ * {@link MockHostOptions.credentials}).
+ */
+export interface MockCredentialSeed {
+    /** Template alias this credential was issued from. */
+    templateAlias?: string;
+
+    /** Boost URI this credential was issued from. */
+    boostUri?: string;
+
+    /** Human-readable credential name (used in toasts and mock VC data). */
+    name?: string;
+
+    /**
+     * Recipient identifier (profileId or DID). Defaults to the mock user
+     * (i.e. a credential the user holds). Set this to model credentials the
+     * user has issued to other people.
+     */
+    recipient?: string;
+
+    /** Claim status. @default 'claimed' */
+    status?: 'pending' | 'claimed' | 'revoked';
 }
 
 /**
@@ -568,6 +725,7 @@ export interface GetCountersResponse {
  */
 export type ErrorCode =
     | 'LC_TIMEOUT'
+    | 'LC_NOT_EMBEDDED'
     | 'LC_UNAUTHENTICATED'
     | 'CREDENTIAL_NOT_FOUND'
     | 'USER_REJECTED'