mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 14:08:21 +00:00
* fix: Only Hand Out OpenID Access Tokens the Bearer Verifier Accepts The OpenID reuse path in refreshController and the post-refresh fallback in getOpenIDAppAuthToken returned the cached access token as the app auth token whenever its exp was in the future. Entra issues Microsoft Graph access tokens to sign-in clients by default; their aud names Graph, so the bearer verifier rejects them and every protected request answers 401 until the client loops. Both paths now require the access token's aud to name the client id or an OPENID_AUDIENCE entry, the same audiences the verifier accepts. The reuse path refreshes with the IdP instead, and the post-refresh fallback keeps opaque tokens as before. Audience parsing is shared with openIdJwtStrategy. Related to #17791 * test: Exercise Real OpenID Audience Helpers in AuthService Spec The AuthService spec stubbed the audience helpers as pass-throughs, so it could not catch a foreign-audience access token escaping the post-refresh fallback. Use the real exports and cover Graph-audience, configured-audience and opaque access tokens through setOpenIDAuthTokens.
1165 lines
38 KiB
JavaScript
1165 lines
38 KiB
JavaScript
const { SystemRoles } = require('librechat-data-provider');
|
||
|
||
// --- Capture JwtStrategy inputs ---
|
||
let capturedStrategyOptions;
|
||
let capturedVerifyCallback;
|
||
const mockAuthUserDocCacheStore = {
|
||
get: jest.fn(),
|
||
set: jest.fn(),
|
||
delete: jest.fn(),
|
||
};
|
||
const mockGetLogStores = jest.fn(() => mockAuthUserDocCacheStore);
|
||
const mockGetTenantId = jest.fn();
|
||
const mockRunAsSystem = jest.fn((callback) => callback());
|
||
jest.mock('passport-jwt', () => ({
|
||
Strategy: jest.fn((opts, verifyCallback) => {
|
||
capturedStrategyOptions = opts;
|
||
capturedVerifyCallback = verifyCallback;
|
||
return { name: 'jwt' };
|
||
}),
|
||
ExtractJwt: {
|
||
fromAuthHeaderAsBearerToken: jest.fn(() => 'mock-extractor'),
|
||
},
|
||
}));
|
||
jest.mock('jwks-rsa', () => ({
|
||
passportJwtSecret: jest.fn(() => 'mock-secret-provider'),
|
||
}));
|
||
jest.mock('https-proxy-agent', () => ({
|
||
HttpsProxyAgent: jest.fn(),
|
||
}));
|
||
jest.mock('@librechat/data-schemas', () => ({
|
||
logger: { info: jest.fn(), warn: jest.fn(), debug: jest.fn(), error: jest.fn() },
|
||
getTenantId: mockGetTenantId,
|
||
runAsSystem: mockRunAsSystem,
|
||
}));
|
||
jest.mock('@librechat/api', () => ({
|
||
isEnabled: jest.fn(() => false),
|
||
isTokenRetired: jest.requireActual('@librechat/api').isTokenRetired,
|
||
continueAfterBearerRetirement: jest.requireActual('@librechat/api').continueAfterBearerRetirement,
|
||
findOpenIDUser: jest.fn(),
|
||
getOpenIdEmail: jest.requireActual('@librechat/api').getOpenIdEmail,
|
||
getOpenIdIssuer: jest.fn(() => 'https://issuer.example.com'),
|
||
normalizeOpenIdIssuer: jest.requireActual('@librechat/api').normalizeOpenIdIssuer,
|
||
buildAuthUserDocCacheKey: jest.fn(() => 'auth-user-doc-key'),
|
||
getAuthUserDocCacheMode: jest.fn(() => 'off'),
|
||
getCurrentCachedAuthUserDoc: jest.fn(),
|
||
isAuthUserAdmissible: (...args) =>
|
||
jest.requireActual('@librechat/api').isAuthUserAdmissible(...args),
|
||
getValidOpenIdReuseUserId: jest.fn(),
|
||
invalidateCachedAuthUserDoc: jest.fn(),
|
||
setCachedAuthUserDoc: jest.fn(),
|
||
timeAuthUserLookup: jest.requireActual('@librechat/api').timeAuthUserLookup,
|
||
getHttpsProxyAgent: jest.fn(() => undefined),
|
||
isAccessTokenJwt: jest.requireActual('@librechat/api').isAccessTokenJwt,
|
||
getOpenIDBearerAudiences: jest.requireActual('@librechat/api').getOpenIDBearerAudiences,
|
||
math: jest.fn((val, fallback) => fallback),
|
||
}));
|
||
jest.mock('~/models', () => ({
|
||
findUser: jest.fn(),
|
||
updateUser: jest.fn(),
|
||
isAgentTriggerPrincipalActive: jest.fn(() => true),
|
||
}));
|
||
jest.mock('~/server/services/Files/strategies', () => ({
|
||
getStrategyFunctions: jest.fn(() => ({
|
||
saveBuffer: jest.fn().mockResolvedValue('/fake/path/to/avatar.png'),
|
||
})),
|
||
}));
|
||
jest.mock('~/server/services/Config', () => ({
|
||
getAppConfig: jest.fn().mockResolvedValue({}),
|
||
}));
|
||
jest.mock('~/cache/getLogStores', () => mockGetLogStores);
|
||
|
||
const {
|
||
buildAuthUserDocCacheKey,
|
||
findOpenIDUser,
|
||
getAuthUserDocCacheMode,
|
||
getCurrentCachedAuthUserDoc,
|
||
getValidOpenIdReuseUserId,
|
||
invalidateCachedAuthUserDoc,
|
||
setCachedAuthUserDoc,
|
||
} = require('@librechat/api');
|
||
const openIdJwtLogin = require('./openIdJwtStrategy');
|
||
const { findUser, updateUser, isAgentTriggerPrincipalActive } = require('~/models');
|
||
|
||
function resetAuthUserDocCacheMocks() {
|
||
mockGetTenantId.mockReturnValue(undefined);
|
||
mockAuthUserDocCacheStore.get.mockResolvedValue(undefined);
|
||
mockAuthUserDocCacheStore.set.mockResolvedValue(undefined);
|
||
mockAuthUserDocCacheStore.delete.mockResolvedValue(undefined);
|
||
mockGetLogStores.mockReturnValue(mockAuthUserDocCacheStore);
|
||
buildAuthUserDocCacheKey.mockReturnValue('auth-user-doc-key');
|
||
getAuthUserDocCacheMode.mockReturnValue('off');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
getValidOpenIdReuseUserId.mockReturnValue(null);
|
||
invalidateCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
setCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
}
|
||
|
||
beforeEach(() => {
|
||
resetAuthUserDocCacheMocks();
|
||
mockRunAsSystem.mockClear();
|
||
isAgentTriggerPrincipalActive.mockResolvedValue(true);
|
||
});
|
||
|
||
function withEnv(env, callback) {
|
||
const previous = Object.fromEntries(Object.keys(env).map((key) => [key, process.env[key]]));
|
||
Object.entries(env).forEach(([key, value]) => {
|
||
if (value === undefined) {
|
||
delete process.env[key];
|
||
return;
|
||
}
|
||
process.env[key] = value;
|
||
});
|
||
try {
|
||
callback();
|
||
} finally {
|
||
Object.entries(previous).forEach(([key, value]) => {
|
||
if (value === undefined) {
|
||
delete process.env[key];
|
||
return;
|
||
}
|
||
process.env[key] = value;
|
||
});
|
||
}
|
||
}
|
||
|
||
// Helper: build a mock openIdConfig
|
||
const mockOpenIdConfig = {
|
||
serverMetadata: () => ({
|
||
issuer: 'https://issuer.example.com',
|
||
jwks_uri: 'https://example.com/.well-known/jwks.json',
|
||
}),
|
||
};
|
||
|
||
// Helper: invoke the captured verify callback
|
||
async function invokeVerify(req, payload) {
|
||
return new Promise((resolve, reject) => {
|
||
capturedVerifyCallback(req, payload, (err, user, info) => {
|
||
if (err) {
|
||
return reject(err);
|
||
}
|
||
resolve({ user, info });
|
||
});
|
||
});
|
||
}
|
||
|
||
describe('openIdJwtStrategy – token validation', () => {
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
});
|
||
|
||
it('requires OpenID JWTs to match the configured client audience and issuer', () => {
|
||
withEnv({ OPENID_CLIENT_ID: 'librechat-client-id', OPENID_AUDIENCE: undefined }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
expect(capturedStrategyOptions).toMatchObject({
|
||
audience: 'librechat-client-id',
|
||
passReqToCallback: true,
|
||
});
|
||
expect(capturedStrategyOptions).not.toHaveProperty('issuer');
|
||
});
|
||
|
||
it('also accepts OPENID_AUDIENCE for providers that mint resource-bound JWTs', () => {
|
||
withEnv({ OPENID_CLIENT_ID: 'librechat-client-id', OPENID_AUDIENCE: 'api://librechat' }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
expect(capturedStrategyOptions).toMatchObject({
|
||
audience: ['librechat-client-id', 'api://librechat'],
|
||
});
|
||
});
|
||
|
||
it('uses a single OPENID_AUDIENCE value when no client ID is configured', () => {
|
||
withEnv({ OPENID_CLIENT_ID: undefined, OPENID_AUDIENCE: 'librechat' }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
expect(capturedStrategyOptions.audience).toBe('librechat');
|
||
});
|
||
|
||
it('splits comma-separated OPENID_AUDIENCE values into multiple accepted audiences', () => {
|
||
withEnv({ OPENID_CLIENT_ID: undefined, OPENID_AUDIENCE: 'librechat,control-plane-web' }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
expect(capturedStrategyOptions.audience).toEqual(['librechat', 'control-plane-web']);
|
||
});
|
||
|
||
it('trims whitespace around comma-separated OPENID_AUDIENCE values', () => {
|
||
withEnv(
|
||
{ OPENID_CLIENT_ID: undefined, OPENID_AUDIENCE: ' librechat , control-plane-web ' },
|
||
() => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
},
|
||
);
|
||
|
||
expect(capturedStrategyOptions.audience).toEqual(['librechat', 'control-plane-web']);
|
||
});
|
||
|
||
it('falls back to OPENID_CLIENT_ID when OPENID_AUDIENCE is empty', () => {
|
||
withEnv({ OPENID_CLIENT_ID: 'client-id-only', OPENID_AUDIENCE: '' }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
expect(capturedStrategyOptions.audience).toBe('client-id-only');
|
||
});
|
||
|
||
it('combines OPENID_CLIENT_ID with comma-separated OPENID_AUDIENCE values and deduplicates', () => {
|
||
withEnv(
|
||
{ OPENID_CLIENT_ID: 'librechat', OPENID_AUDIENCE: 'librechat,control-plane-web' },
|
||
() => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
},
|
||
);
|
||
|
||
expect(capturedStrategyOptions.audience).toEqual(['librechat', 'control-plane-web']);
|
||
});
|
||
|
||
it('rejects OpenID JWTs whose issuer does not match the configured issuer', async () => {
|
||
findOpenIDUser.mockResolvedValue({ user: null, error: null, migration: false });
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user, info } = await invokeVerify(req, {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://other-issuer.example.com',
|
||
exp: 9999999999,
|
||
});
|
||
|
||
expect(user).toBe(false);
|
||
expect(info).toEqual({ message: 'Invalid issuer' });
|
||
expect(findOpenIDUser).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('allows Microsoft Entra tenant issuer values for tenant-independent metadata', async () => {
|
||
const entraConfig = {
|
||
serverMetadata: () => ({
|
||
issuer: 'https://login.microsoftonline.com/{tenantid}/v2.0',
|
||
jwks_uri: 'https://login.microsoftonline.com/common/discovery/v2.0/keys',
|
||
}),
|
||
};
|
||
const user = {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
};
|
||
findOpenIDUser.mockResolvedValue({ user, error: null, migration: false });
|
||
updateUser.mockResolvedValue({});
|
||
openIdJwtLogin(entraConfig);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user: result } = await invokeVerify(req, {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://login.microsoftonline.com/11111111-2222-3333-4444-555555555555/v2.0',
|
||
exp: 9999999999,
|
||
});
|
||
|
||
expect(result).toBeTruthy();
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
});
|
||
|
||
describe('credentialsChangedAt revocation', () => {
|
||
/** Reset landed 500ms into second 1700000010 */
|
||
const credentialsChangedAt = new Date(1700000010500);
|
||
|
||
const runVerify = async (iat) => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
credentialsChangedAt,
|
||
},
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
updateUser.mockResolvedValue({});
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
return invokeVerify(req, {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
iat,
|
||
});
|
||
};
|
||
|
||
it('rejects an OpenID JWT issued before the credential change', async () => {
|
||
const { user } = await runVerify(1700000009);
|
||
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('accepts an OpenID JWT issued after the credential change', async () => {
|
||
const { user } = await runVerify(1700000011);
|
||
|
||
expect(user).toBeTruthy();
|
||
expect(user.id).toBe('user-abc');
|
||
});
|
||
});
|
||
});
|
||
|
||
describe('openIdJwtStrategy – token source handling', () => {
|
||
const baseUser = {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
};
|
||
|
||
const payload = {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
};
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
findOpenIDUser.mockResolvedValue({ user: { ...baseUser }, error: null, migration: false });
|
||
updateUser.mockResolvedValue({});
|
||
|
||
// Initialize the strategy so capturedVerifyCallback is set
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
it('should read all tokens from session when available', async () => {
|
||
const req = {
|
||
headers: { authorization: 'Bearer raw-bearer-token' },
|
||
session: {
|
||
openidTokens: {
|
||
accessToken: 'session-access',
|
||
idToken: 'session-id',
|
||
refreshToken: 'session-refresh',
|
||
},
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens).toEqual({
|
||
access_token: 'session-access',
|
||
id_token: 'session-id',
|
||
refresh_token: 'session-refresh',
|
||
expires_at: undefined,
|
||
});
|
||
});
|
||
|
||
it('should fall back to cookies when session is absent', async () => {
|
||
const req = {
|
||
headers: {
|
||
authorization: 'Bearer raw-bearer-token',
|
||
cookie:
|
||
'openid_access_token=cookie-access; openid_id_token=cookie-id; refreshToken=cookie-refresh',
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens).toEqual({
|
||
access_token: 'cookie-access',
|
||
id_token: 'cookie-id',
|
||
refresh_token: 'cookie-refresh',
|
||
expires_at: undefined,
|
||
});
|
||
});
|
||
|
||
it('should fall back to cookie for idToken only when session lacks it', async () => {
|
||
const req = {
|
||
headers: {
|
||
authorization: 'Bearer raw-bearer-token',
|
||
cookie: 'openid_id_token=cookie-id',
|
||
},
|
||
session: {
|
||
openidTokens: {
|
||
accessToken: 'session-access',
|
||
// idToken intentionally missing
|
||
refreshToken: 'session-refresh',
|
||
},
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens).toEqual({
|
||
access_token: 'session-access',
|
||
id_token: 'cookie-id',
|
||
refresh_token: 'session-refresh',
|
||
expires_at: undefined,
|
||
});
|
||
});
|
||
|
||
const encodeSegment = (value) => Buffer.from(JSON.stringify(value)).toString('base64');
|
||
const makeJwt = (claims, header = { alg: 'RS256' }) =>
|
||
`${encodeSegment(header)}.${encodeSegment(claims)}.signature`;
|
||
|
||
const resourceEnv = { OPENID_CLIENT_ID: 'client-id', OPENID_AUDIENCE: 'api://resource-app' };
|
||
|
||
it('should decline the raw Bearer token when nothing identifies it as an access token', async () => {
|
||
const req = {
|
||
headers: {
|
||
authorization: 'Bearer raw-bearer-token',
|
||
cookie: 'openid_id_token=cookie-id; refreshToken=cookie-refresh',
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
expect(user.federatedTokens.id_token).toBe('cookie-id');
|
||
expect(user.federatedTokens.refresh_token).toBe('cookie-refresh');
|
||
expect(user.federatedTokens.expires_at).toBeUndefined();
|
||
});
|
||
|
||
it('should decline an Entra-shaped ID token rather than reuse it as the OBO assertion', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const claims = { ...payload, aud: 'client-id', nonce: 'n-0S6_WzA2Mj', tid: 'tenant-1' };
|
||
const req = { headers: { authorization: `Bearer ${makeJwt(claims)}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
});
|
||
|
||
it('should decline a multi-audience ID token that also names a configured resource', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const claims = { ...payload, aud: ['client-id', 'api://resource-app'], nonce: 'n-0S6' };
|
||
const req = { headers: { authorization: `Bearer ${makeJwt(claims)}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
});
|
||
|
||
it('should decline an ID token carrying a provider-added scope claim', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const claims = { ...payload, aud: 'client-id', scope: 'openid email profile' };
|
||
const req = { headers: { authorization: `Bearer ${makeJwt(claims)}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
});
|
||
|
||
it('should decline a raw Bearer token carrying the ID-token-only at_hash claim', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const claims = { ...payload, aud: 'api://resource-app', at_hash: 'HK6E_P6Dh8Y93mRN' };
|
||
const req = { headers: { authorization: `Bearer ${makeJwt(claims)}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
});
|
||
|
||
it('should reuse a raw Bearer token whose audience names a configured resource', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const claims = { ...payload, aud: 'api://resource-app' };
|
||
const rawToken = makeJwt(claims);
|
||
const req = { headers: { authorization: `Bearer ${rawToken}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBe(rawToken);
|
||
expect(user.federatedTokens.expires_at).toBe(payload.exp);
|
||
});
|
||
|
||
it('should reuse a raw Bearer token declaring the RFC 9068 `at+jwt` header type', async () => {
|
||
withEnv(resourceEnv, () => openIdJwtLogin(mockOpenIdConfig));
|
||
|
||
const rawToken = makeJwt(payload, { alg: 'RS256', typ: 'at+JWT' });
|
||
const req = { headers: { authorization: `Bearer ${rawToken}` } };
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBe(rawToken);
|
||
});
|
||
|
||
it('should decline a raw Bearer token whose only audience is the OIDC client id', async () => {
|
||
withEnv({ OPENID_CLIENT_ID: 'client-id', OPENID_AUDIENCE: 'client-id' }, () => {
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
const claims = { ...payload, aud: 'client-id', scp: 'User.Read' };
|
||
const req = { headers: { authorization: `Bearer ${makeJwt(claims)}` } };
|
||
|
||
const { user } = await invokeVerify(req, claims);
|
||
|
||
expect(user.federatedTokens.access_token).toBeUndefined();
|
||
});
|
||
|
||
it('should decode expires_at from a session access token that is itself a JWT', async () => {
|
||
const sessionAccessExp = 1234567890;
|
||
const sessionAccessToken = `header.${Buffer.from(
|
||
JSON.stringify({ sub: 'oidc-123', exp: sessionAccessExp }),
|
||
).toString('base64')}.signature`;
|
||
const req = {
|
||
headers: { authorization: 'Bearer raw-bearer-token' },
|
||
session: {
|
||
openidTokens: {
|
||
accessToken: sessionAccessToken,
|
||
idToken: 'session-id',
|
||
refreshToken: 'session-refresh',
|
||
},
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBe(sessionAccessToken);
|
||
expect(user.federatedTokens.expires_at).toBe(sessionAccessExp);
|
||
expect(user.federatedTokens.expires_at).not.toBe(payload.exp);
|
||
});
|
||
|
||
it('should store an opaque session access token with no expiry alongside a decodable stale ID token', async () => {
|
||
const staleIdToken = `header.${Buffer.from(
|
||
JSON.stringify({ sub: 'oidc-123', exp: Math.floor(Date.now() / 1000) - 3600 }),
|
||
).toString('base64')}.signature`;
|
||
const req = {
|
||
headers: { authorization: 'Bearer raw-bearer-token' },
|
||
session: {
|
||
openidTokens: {
|
||
accessToken: 'opaque-session-access',
|
||
idToken: staleIdToken,
|
||
refreshToken: 'session-refresh',
|
||
},
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBe('opaque-session-access');
|
||
expect(user.federatedTokens.id_token).toBe(staleIdToken);
|
||
expect(user.federatedTokens.expires_at).toBeUndefined();
|
||
});
|
||
|
||
it('should set id_token to undefined when not available in session or cookies', async () => {
|
||
const req = {
|
||
headers: {
|
||
authorization: 'Bearer raw-bearer-token',
|
||
cookie: 'openid_access_token=cookie-access; refreshToken=cookie-refresh',
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBe('cookie-access');
|
||
expect(user.federatedTokens.id_token).toBeUndefined();
|
||
expect(user.federatedTokens.refresh_token).toBe('cookie-refresh');
|
||
});
|
||
|
||
it('should keep id_token and access_token as distinct values from cookies', async () => {
|
||
const req = {
|
||
headers: {
|
||
authorization: 'Bearer raw-bearer-token',
|
||
cookie:
|
||
'openid_access_token=the-access-token; openid_id_token=the-id-token; refreshToken=the-refresh',
|
||
},
|
||
};
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.federatedTokens.access_token).toBe('the-access-token');
|
||
expect(user.federatedTokens.id_token).toBe('the-id-token');
|
||
expect(user.federatedTokens.access_token).not.toBe(user.federatedTokens.id_token);
|
||
});
|
||
});
|
||
|
||
describe('openIdJwtStrategy – auth user document cache', () => {
|
||
const payload = {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
};
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
|
||
const baseUser = {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
email: 'test@example.com',
|
||
};
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
resetAuthUserDocCacheMocks();
|
||
updateUser.mockResolvedValue({});
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
it('does not initialize the cache store while cache mode is off', async () => {
|
||
findOpenIDUser.mockResolvedValue({ user: { ...baseUser }, error: null, migration: false });
|
||
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
expect(mockGetLogStores).not.toHaveBeenCalled();
|
||
expect(getCurrentCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
expect(setCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('uses the cached user document in on mode without a database lookup', async () => {
|
||
mockGetTenantId.mockReturnValue('tenant-a');
|
||
const cachedUser = {
|
||
_id: 'cached-user',
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
email: 'cached@example.com',
|
||
tenantId: 'tenant-a',
|
||
};
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(cachedUser);
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(buildAuthUserDocCacheKey).toHaveBeenCalledWith({
|
||
strategy: 'openid-jwt',
|
||
subject: payload.sub,
|
||
issuer: 'https://issuer.example.com',
|
||
tenantId: 'tenant-a',
|
||
});
|
||
expect(findOpenIDUser).not.toHaveBeenCalled();
|
||
expect(user).toMatchObject({
|
||
id: 'cached-user',
|
||
email: 'cached@example.com',
|
||
idOnTheSource: null,
|
||
});
|
||
expect(setCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
expect(invalidateCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('checks the cached document against the stored user and reads it fully when stale', async () => {
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
findOpenIDUser.mockResolvedValue({ user: { ...baseUser }, error: null, migration: false });
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(getCurrentCachedAuthUserDoc).toHaveBeenCalledWith(
|
||
mockAuthUserDocCacheStore,
|
||
'auth-user-doc-key',
|
||
{ findUser },
|
||
);
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
expect(user).toMatchObject({ id: 'user-abc' });
|
||
});
|
||
|
||
it('serves a cache hit without a second deletion fence read', async () => {
|
||
mockGetTenantId.mockReturnValue('tenant-a');
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue({
|
||
_id: 'cached-user',
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
tenantId: 'tenant-a',
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user).toMatchObject({ id: 'cached-user' });
|
||
expect(findOpenIDUser).not.toHaveBeenCalled();
|
||
expect(isAgentTriggerPrincipalActive).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('rejects an OpenID user read from the database while account deletion is fenced', async () => {
|
||
mockGetTenantId.mockReturnValue('tenant-a');
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
/** A fenced user fails the freshness check, so the hit falls back to the database. */
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
findOpenIDUser.mockResolvedValue({ user: { ...baseUser }, error: null, migration: false });
|
||
isAgentTriggerPrincipalActive.mockResolvedValue(false);
|
||
|
||
const result = await invokeVerify(req, payload);
|
||
|
||
expect(result).toEqual({
|
||
user: false,
|
||
info: {
|
||
message: 'Account deletion is in progress',
|
||
code: 'ACCOUNT_DELETION_IN_PROGRESS',
|
||
},
|
||
});
|
||
expect(mockRunAsSystem).toHaveBeenCalledWith(expect.any(Function));
|
||
expect(isAgentTriggerPrincipalActive).toHaveBeenCalledWith('user-abc');
|
||
expect(setCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('populates the cache after a miss with the fresh user document', async () => {
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
let lookupAt;
|
||
findOpenIDUser.mockImplementation(async () => {
|
||
lookupAt = Date.now();
|
||
return { user: { ...baseUser }, error: null, migration: false };
|
||
});
|
||
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
expect(setCachedAuthUserDoc).toHaveBeenCalledWith(
|
||
mockAuthUserDocCacheStore,
|
||
'auth-user-doc-key',
|
||
expect.objectContaining({ id: 'user-abc' }),
|
||
expect.any(Number),
|
||
);
|
||
/** The write is stamped with when the lookup began, so a slow lookup is not cached. */
|
||
expect(setCachedAuthUserDoc.mock.calls[0][3]).toBeLessThanOrEqual(lookupAt);
|
||
expect(invalidateCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('rejects a cached user document from another tenant', async () => {
|
||
mockGetTenantId.mockReturnValue('tenant-b');
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue({
|
||
_id: 'tenant-a-user',
|
||
role: SystemRoles.ADMIN,
|
||
provider: 'openid',
|
||
email: 'cached@example.com',
|
||
tenantId: 'tenant-a',
|
||
});
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, _id: { toString: () => 'tenant-b-user' }, tenantId: 'tenant-b' },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(buildAuthUserDocCacheKey).toHaveBeenCalledWith({
|
||
strategy: 'openid-jwt',
|
||
subject: payload.sub,
|
||
issuer: 'https://issuer.example.com',
|
||
tenantId: 'tenant-b',
|
||
});
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
expect(user).toMatchObject({ id: 'tenant-b-user', tenantId: 'tenant-b' });
|
||
expect(setCachedAuthUserDoc).toHaveBeenCalledWith(
|
||
mockAuthUserDocCacheStore,
|
||
'auth-user-doc-key',
|
||
expect.objectContaining({ id: 'tenant-b-user', tenantId: 'tenant-b' }),
|
||
expect.any(Number),
|
||
);
|
||
});
|
||
|
||
it('uses the signed OpenID user id as cache scope before tenant context is available', async () => {
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getValidOpenIdReuseUserId.mockReturnValue('tenant-a-user');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue({
|
||
_id: 'tenant-a-user',
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
email: 'cached@example.com',
|
||
tenantId: 'tenant-a',
|
||
});
|
||
|
||
const { user } = await invokeVerify(
|
||
{
|
||
headers: {
|
||
authorization: 'Bearer tok',
|
||
cookie: 'openid_user_id=signed-user-id',
|
||
},
|
||
session: {},
|
||
},
|
||
payload,
|
||
);
|
||
|
||
expect(getValidOpenIdReuseUserId).toHaveBeenCalledWith('signed-user-id');
|
||
expect(buildAuthUserDocCacheKey).toHaveBeenCalledWith({
|
||
strategy: 'openid-jwt',
|
||
subject: payload.sub,
|
||
issuer: 'https://issuer.example.com',
|
||
userId: 'tenant-a-user',
|
||
});
|
||
expect(findOpenIDUser).not.toHaveBeenCalled();
|
||
expect(user).toMatchObject({ id: 'tenant-a-user', tenantId: 'tenant-a' });
|
||
});
|
||
|
||
it('does not cache a lookup result outside the active tenant scope', async () => {
|
||
mockGetTenantId.mockReturnValue('tenant-b');
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue(undefined);
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, tenantId: 'tenant-a' },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findOpenIDUser).toHaveBeenCalled();
|
||
expect(setCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('invalidates instead of populating when login mutates the user', async () => {
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, role: undefined },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(updateUser).toHaveBeenCalledWith('user-abc', { role: SystemRoles.USER });
|
||
expect(setCachedAuthUserDoc).not.toHaveBeenCalled();
|
||
expect(invalidateCachedAuthUserDoc).toHaveBeenCalledWith(mockAuthUserDocCacheStore, {
|
||
userId: 'user-abc',
|
||
cacheKey: 'auth-user-doc-key',
|
||
});
|
||
});
|
||
});
|
||
|
||
describe('openIdJwtStrategy: retired token cutoffs', () => {
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
|
||
const baseUser = {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
email: 'test@example.com',
|
||
};
|
||
|
||
const enrolledAt = new Date('2026-01-01T00:00:30.500Z');
|
||
const enrolledSecond = Math.floor(enrolledAt.getTime() / 1000);
|
||
|
||
/** The provider mints this token, so `iat` is the only stamp it can ever carry. */
|
||
const makePayload = (iat) => ({
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
...(iat === undefined ? {} : { iat }),
|
||
});
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
resetAuthUserDocCacheMocks();
|
||
updateUser.mockResolvedValue({});
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
it('refuses a federated bearer minted before enrollment', async () => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, twoFactorEnrolledAt: enrolledAt },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user, info } = await invokeVerify(req, makePayload(enrolledSecond - 1));
|
||
|
||
expect(user).toBe(false);
|
||
expect(info).toEqual({ message: 'Token predates enrollment or password reset' });
|
||
expect(updateUser).not.toHaveBeenCalled();
|
||
});
|
||
|
||
it('surrenders the resetting second, which whole-second `iat` cannot tell apart', async () => {
|
||
const credentialsChangedAt = new Date('2026-01-01T00:00:30.500Z');
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, credentialsChangedAt },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(
|
||
req,
|
||
makePayload(Math.floor(credentialsChangedAt.getTime() / 1000)),
|
||
);
|
||
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('accepts a federated bearer minted after both cutoffs', async () => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: {
|
||
...baseUser,
|
||
twoFactorEnrolledAt: enrolledAt,
|
||
credentialsChangedAt: new Date('2025-06-01T00:00:00.000Z'),
|
||
},
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, makePayload(enrolledSecond + 1));
|
||
|
||
expect(user).toMatchObject({ id: 'user-abc', email: 'test@example.com' });
|
||
});
|
||
|
||
it('leaves an account that carries neither cutoff alone, undatable token included', async () => {
|
||
findOpenIDUser.mockResolvedValue({ user: { ...baseUser }, error: null, migration: false });
|
||
|
||
const { user } = await invokeVerify(req, makePayload(undefined));
|
||
|
||
expect(user).toMatchObject({ id: 'user-abc' });
|
||
});
|
||
|
||
it('refuses a bearer it cannot date at all once a cutoff is set', async () => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { ...baseUser, twoFactorEnrolledAt: enrolledAt },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, makePayload(undefined));
|
||
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('dates the bearer against a cached stamp that came back serialized', async () => {
|
||
getAuthUserDocCacheMode.mockReturnValue('on');
|
||
getCurrentCachedAuthUserDoc.mockResolvedValue({
|
||
_id: 'cached-user',
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
email: 'cached@example.com',
|
||
/** Redis round-trips `Date` through JSON, so the cutoff arrives as an ISO string */
|
||
twoFactorEnrolledAt: enrolledAt.toISOString(),
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, makePayload(enrolledSecond - 1));
|
||
|
||
expect(user).toBe(false);
|
||
expect(findOpenIDUser).not.toHaveBeenCalled();
|
||
});
|
||
});
|
||
|
||
describe('openIdJwtStrategy – idOnTheSource boundary coercion', () => {
|
||
const payload = {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
};
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
updateUser.mockResolvedValue({});
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
it('coerces missing idOnTheSource to null', async () => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: { _id: { toString: () => 'user-abc' }, role: SystemRoles.USER, provider: 'openid' },
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.idOnTheSource).toBeNull();
|
||
});
|
||
|
||
it('preserves a stored idOnTheSource', async () => {
|
||
findOpenIDUser.mockResolvedValue({
|
||
user: {
|
||
_id: { toString: () => 'user-abc' },
|
||
role: SystemRoles.USER,
|
||
provider: 'openid',
|
||
idOnTheSource: 'entra-oid-123',
|
||
},
|
||
error: null,
|
||
migration: false,
|
||
});
|
||
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(user.idOnTheSource).toBe('entra-oid-123');
|
||
});
|
||
});
|
||
|
||
describe('openIdJwtStrategy – OPENID_EMAIL_CLAIM', () => {
|
||
const payload = {
|
||
sub: 'oidc-123',
|
||
email: 'test@example.com',
|
||
preferred_username: 'testuser',
|
||
upn: 'test@corp.example.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
};
|
||
|
||
beforeEach(() => {
|
||
jest.clearAllMocks();
|
||
delete process.env.OPENID_EMAIL_CLAIM;
|
||
|
||
// Use real findOpenIDUser so it delegates to the findUser mock
|
||
const realFindOpenIDUser = jest.requireActual('@librechat/api').findOpenIDUser;
|
||
findOpenIDUser.mockImplementation(realFindOpenIDUser);
|
||
|
||
findUser.mockResolvedValue(null);
|
||
updateUser.mockResolvedValue({});
|
||
|
||
openIdJwtLogin(mockOpenIdConfig);
|
||
});
|
||
|
||
afterEach(() => {
|
||
delete process.env.OPENID_EMAIL_CLAIM;
|
||
});
|
||
|
||
it('should use the default email when OPENID_EMAIL_CLAIM is not set', async () => {
|
||
const existingUser = {
|
||
_id: 'user-id-1',
|
||
provider: 'openid',
|
||
openidId: payload.sub,
|
||
openidIssuer: 'https://issuer.example.com',
|
||
email: payload.email,
|
||
role: SystemRoles.USER,
|
||
};
|
||
findUser.mockImplementation(async (query) => {
|
||
if (query.openidId === payload.sub && query.openidIssuer === 'https://issuer.example.com') {
|
||
return existingUser;
|
||
}
|
||
return null;
|
||
});
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledWith({
|
||
openidId: payload.sub,
|
||
openidIssuer: 'https://issuer.example.com',
|
||
});
|
||
});
|
||
|
||
it('should use OPENID_EMAIL_CLAIM when set for email lookup', async () => {
|
||
process.env.OPENID_EMAIL_CLAIM = 'upn';
|
||
findUser.mockResolvedValue(null);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledTimes(2);
|
||
expect(findUser.mock.calls[0][0]).toEqual({
|
||
openidId: payload.sub,
|
||
openidIssuer: 'https://issuer.example.com',
|
||
});
|
||
expect(findUser.mock.calls[1][0]).toEqual({
|
||
email: 'test@corp.example.com',
|
||
});
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('should fall back to default chain when OPENID_EMAIL_CLAIM points to missing claim', async () => {
|
||
process.env.OPENID_EMAIL_CLAIM = 'nonexistent_claim';
|
||
findUser.mockResolvedValue(null);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user } = await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledWith({ email: payload.email });
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('should reject login when email fallback finds user with mismatched openidId', async () => {
|
||
const emailMatchWithDifferentSub = {
|
||
_id: 'user-id-2',
|
||
provider: 'openid',
|
||
openidId: 'different-sub',
|
||
email: payload.email,
|
||
role: SystemRoles.USER,
|
||
};
|
||
|
||
findUser.mockImplementation(async (query) => {
|
||
if (query.$or) {
|
||
return null;
|
||
}
|
||
if (query.email === payload.email) {
|
||
return emailMatchWithDifferentSub;
|
||
}
|
||
return null;
|
||
});
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user, info } = await invokeVerify(req, payload);
|
||
|
||
expect(user).toBe(false);
|
||
expect(info).toEqual({ message: 'auth_failed' });
|
||
});
|
||
|
||
it('should trim whitespace from OPENID_EMAIL_CLAIM', async () => {
|
||
process.env.OPENID_EMAIL_CLAIM = ' upn ';
|
||
findUser.mockResolvedValue(null);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledWith({ email: 'test@corp.example.com' });
|
||
});
|
||
|
||
it('should ignore empty string OPENID_EMAIL_CLAIM and use default fallback', async () => {
|
||
process.env.OPENID_EMAIL_CLAIM = '';
|
||
findUser.mockResolvedValue(null);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledWith({ email: payload.email });
|
||
});
|
||
|
||
it('should ignore whitespace-only OPENID_EMAIL_CLAIM and use default fallback', async () => {
|
||
process.env.OPENID_EMAIL_CLAIM = ' ';
|
||
findUser.mockResolvedValue(null);
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
await invokeVerify(req, payload);
|
||
|
||
expect(findUser).toHaveBeenCalledWith({ email: payload.email });
|
||
});
|
||
|
||
it('should resolve undefined email when payload is null', async () => {
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user } = await invokeVerify(req, null);
|
||
|
||
expect(user).toBe(false);
|
||
});
|
||
|
||
it('should attempt email lookup via preferred_username fallback when email claim is absent', async () => {
|
||
const payloadNoEmail = {
|
||
sub: 'oidc-new-sub',
|
||
preferred_username: 'legacy@corp.com',
|
||
upn: 'legacy@corp.com',
|
||
iss: 'https://issuer.example.com',
|
||
exp: 9999999999,
|
||
};
|
||
|
||
const legacyUser = {
|
||
_id: 'legacy-db-id',
|
||
email: 'legacy@corp.com',
|
||
openidId: null,
|
||
role: SystemRoles.USER,
|
||
};
|
||
|
||
findUser.mockImplementation(async (query) => {
|
||
if (query.$or) {
|
||
return null;
|
||
}
|
||
if (query.email === 'legacy@corp.com') {
|
||
return legacyUser;
|
||
}
|
||
return null;
|
||
});
|
||
|
||
const req = { headers: { authorization: 'Bearer tok' }, session: {} };
|
||
const { user } = await invokeVerify(req, payloadNoEmail);
|
||
|
||
expect(findUser).toHaveBeenCalledTimes(2);
|
||
expect(findUser.mock.calls[1][0]).toEqual({ email: 'legacy@corp.com' });
|
||
expect(user).toBeTruthy();
|
||
expect(updateUser).toHaveBeenCalledWith(
|
||
'legacy-db-id',
|
||
expect.objectContaining({
|
||
provider: 'openid',
|
||
openidId: payloadNoEmail.sub,
|
||
openidIssuer: 'https://issuer.example.com',
|
||
}),
|
||
);
|
||
});
|
||
});
|