Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🛜 ci: OpenID Strategy Test Async Handling (#5613)
Ruben Talstra93f5713c7470
diff --git a/api/strategies/openidStrategy.spec.js b/api/strategies/openidStrategy.spec.jsindex e2e7af87a6..7b8a3107a0 100644--- a/api/strategies/openidStrategy.spec.js+++ b/api/strategies/openidStrategy.spec.js@@ -1,175 +1,301 @@+const fetch = require('node-fetch');const jwtDecode = require('jsonwebtoken/decode');const { Issuer, Strategy: OpenIDStrategy } = require('openid-client');-const mongoose = require('mongoose');-const { MongoMemoryServer } = require('mongodb-memory-server');-const User = require('~/models/User');+const { findUser, createUser, updateUser } = require('~/models/userMethods');const setupOpenId = require('./openidStrategy');-jest.mock('jsonwebtoken/decode');+// --- Mocks ---+jest.mock('node-fetch');jest.mock('openid-client');-+jest.mock('jsonwebtoken/decode');jest.mock('~/server/services/Files/strategies', () => ({getStrategyFunctions: jest.fn(() => ({- saveBuffer: jest.fn(),+ // You can modify this mock as needed (here returning a dummy function)+ saveBuffer: jest.fn().mockResolvedValue('/fake/path/to/avatar.png'),})),}));+jest.mock('~/models/userMethods', () => ({+ findUser: jest.fn(),+ createUser: jest.fn(),+ updateUser: jest.fn(),+}));+jest.mock('~/server/utils/crypto', () => ({+ hashToken: jest.fn().mockResolvedValue('hashed-token'),+}));+jest.mock('~/server/utils', () => ({+ isEnabled: jest.fn(() => false), // default to false, override per test if needed+}));+jest.mock('~/config', () => ({+ logger: {+ info: jest.fn(),+ debug: jest.fn(),+ error: jest.fn(),+ },+}));+// Mock Issuer.discover so that setupOpenId gets a fake issuer and clientIssuer.discover = jest.fn().mockResolvedValue({- Client: jest.fn(),+ id_token_signing_alg_values_supported: ['RS256'],+ Client: jest.fn().mockImplementation((clientMetadata) => {+ return {+ metadata: clientMetadata,+ };+ }),+});++// To capture the verify callback from the strategy, we grab it from the mock constructor+let verifyCallback;+OpenIDStrategy.mockImplementation((options, verify) => {+ verifyCallback = verify;+ return { name: 'openid', options, verify };});describe('setupOpenId', () => {- const OLD_ENV = process.env;- describe('OpenIDStrategy', () => {- let validateFn, mongoServer;-- beforeAll(async () => {- mongoServer = await MongoMemoryServer.create();- const mongoUri = mongoServer.getUri();- await mongoose.connect(mongoUri);+ // Helper to wrap the verify callback in a promise+ const validate = (tokenset, userinfo) =>+ new Promise((resolve, reject) => {+ verifyCallback(tokenset, userinfo, (err, user, details) => {+ if (err) {+ reject(err);+ } else {+ resolve({ user, details });+ }+ });});- afterAll(async () => {- process.env = OLD_ENV;- await mongoose.disconnect();- await mongoServer.stop();- });+ const tokenset = {+ id_token: 'fake_id_token',+ access_token: 'fake_access_token',+ };- beforeEach(async () => {- jest.clearAllMocks();- await User.deleteMany({});- process.env = {- ...OLD_ENV,- OPENID_ISSUER: 'https://fake-issuer.com',- OPENID_CLIENT_ID: 'fake_client_id',- OPENID_CLIENT_SECRET: 'fake_client_secret',- DOMAIN_SERVER: 'https://example.com',- OPENID_CALLBACK_URL: '/callback',- OPENID_SCOPE: 'openid profile email',- OPENID_REQUIRED_ROLE: 'requiredRole',- OPENID_REQUIRED_ROLE_PARAMETER_PATH: 'roles',- OPENID_REQUIRED_ROLE_TOKEN_KIND: 'id',- };-- jwtDecode.mockReturnValue({- roles: ['requiredRole'],- });+ const baseUserinfo = {+ sub: '1234',+ email: '[email protected]',+ email_verified: true,+ given_name: 'First',+ family_name: 'Last',+ name: 'My Full',+ username: 'flast',+ picture: 'https://example.com/avatar.png',+ };++ beforeEach(async () => {+ // Clear previous mock calls and reset implementations+ jest.clearAllMocks();- //call setup so we can grab a reference to the validate function- await setupOpenId();- validateFn = OpenIDStrategy.mock.calls[0][1];+ // Reset environment variables needed by the strategy+ process.env.OPENID_ISSUER = 'https://fake-issuer.com';+ process.env.OPENID_CLIENT_ID = 'fake_client_id';+ process.env.OPENID_CLIENT_SECRET = 'fake_client_secret';+ process.env.DOMAIN_SERVER = 'https://example.com';+ process.env.OPENID_CALLBACK_URL = '/callback';+ process.env.OPENID_SCOPE = 'openid profile email';+ process.env.OPENID_REQUIRED_ROLE = 'requiredRole';+ process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH = 'roles';+ process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND = 'id';+ delete process.env.OPENID_USERNAME_CLAIM;+ delete process.env.OPENID_NAME_CLAIM;+ delete process.env.PROXY;++ // Default jwtDecode mock returns a token that includes the required role.+ jwtDecode.mockReturnValue({+ roles: ['requiredRole'],});- const tokenset = {- id_token: 'fake_id_token',- };+ // By default, assume that no user is found, so createUser will be called+ findUser.mockResolvedValue(null);+ createUser.mockImplementation(async (userData) => {+ // simulate created user with an _id property+ return { _id: 'newUserId', ...userData };+ });+ updateUser.mockImplementation(async (id, userData) => {+ return { _id: id, ...userData };+ });- const userinfo = {- sub: '1234',- email: '[email protected]',- email_verified: true,- given_name: 'First',- family_name: 'Last',- name: 'My Full',- username: 'flast',+ // For image download, simulate a successful response+ const fakeBuffer = Buffer.from('fake image');+ const fakeResponse = {+ ok: true,+ buffer: jest.fn().mockResolvedValue(fakeBuffer),};+ fetch.mockResolvedValue(fakeResponse);- const userModel = {- openidId: userinfo.sub,- email: userinfo.email,- };+ // Finally, call the setup function so that passport.use gets called+ await setupOpenId();+ });- it('should set username correctly for a new user when username claim exists', async () => {- const expectUsername = userinfo.username.toLowerCase();- await validateFn(tokenset, userinfo, (err, user) => {- expect(err).toBe(null);- expect(user.username).toBe(expectUsername);- });+ it('should create a new user with correct username when username claim exists', async () => {+ // Arrange – our userinfo already has username 'flast'+ const userinfo = { ...baseUserinfo };- await expect(User.exists({ username: expectUsername })).resolves.not.toBeNull();- });+ // Act+ const { user } = await validate(tokenset, userinfo);- it('should set username correctly for a new user when given_name claim exists, but username does not', async () => {- let userinfo_modified = { ...userinfo };- delete userinfo_modified.username;- const expectUsername = userinfo.given_name.toLowerCase();+ // Assert+ expect(user.username).toBe(userinfo.username);+ expect(createUser).toHaveBeenCalledWith(+ expect.objectContaining({+ provider: 'openid',+ openidId: userinfo.sub,+ username: userinfo.username,+ email: userinfo.email,+ name: `${userinfo.given_name} ${userinfo.family_name}`,+ }),+ true,+ true,+ );+ });- await validateFn(tokenset, userinfo_modified, (err, user) => {- expect(err).toBe(null);- expect(user.username).toBe(expectUsername);- });- await expect(User.exists({ username: expectUsername })).resolves.not.toBeNull();- });+ it('should use given_name as username when username claim is missing', async () => {+ // Arrange – remove username from userinfo+ const userinfo = { ...baseUserinfo };+ delete userinfo.username;+ // Expect the username to be the given name (unchanged case)+ const expectUsername = userinfo.given_name;- it('should set username correctly for a new user when email claim exists, but username and given_name do not', async () => {- let userinfo_modified = { ...userinfo };- delete userinfo_modified.username;- delete userinfo_modified.given_name;- const expectUsername = userinfo.email.toLowerCase();+ // Act+ const { user } = await validate(tokenset, userinfo);- await validateFn(tokenset, userinfo_modified, (err, user) => {- expect(err).toBe(null);- expect(user.username).toBe(expectUsername);- });- await expect(User.exists({ username: expectUsername })).resolves.not.toBeNull();- });+ // Assert+ expect(user.username).toBe(expectUsername);+ expect(createUser).toHaveBeenCalledWith(+ expect.objectContaining({ username: expectUsername }),+ true,+ true,+ );+ });- it('should set username correctly for a new user when using OPENID_USERNAME_CLAIM', async () => {- process.env.OPENID_USERNAME_CLAIM = 'sub';- const expectUsername = userinfo.sub.toLowerCase();+ it('should use email as username when username and given_name are missing', async () => {+ // Arrange – remove username and given_name+ const userinfo = { ...baseUserinfo };+ delete userinfo.username;+ delete userinfo.given_name;+ const expectUsername = userinfo.email;- await validateFn(tokenset, userinfo, (err, user) => {- expect(err).toBe(null);- expect(user.username).toBe(expectUsername);- });- await expect(User.exists({ username: expectUsername })).resolves.not.toBeNull();- });+ // Act+ const { user } = await validate(tokenset, userinfo);- it('should set name correctly for a new user with first and last names', async () => {- const expectName = userinfo.given_name + ' ' + userinfo.family_name;- await validateFn(tokenset, userinfo, (err, user) => {- expect(err).toBe(null);- expect(user.name).toBe(expectName);- });- await expect(User.exists({ name: expectName })).resolves.not.toBeNull();- });+ // Assert+ expect(user.username).toBe(expectUsername);+ expect(createUser).toHaveBeenCalledWith(+ expect.objectContaining({ username: expectUsername }),+ true,+ true,+ );+ });- it('should set name correctly for a new user using OPENID_NAME_CLAIM', async () => {- const expectName = 'Custom Name';- process.env.OPENID_NAME_CLAIM = 'name';- let userinfo_modified = { ...userinfo, name: expectName };+ it('should override username with OPENID_USERNAME_CLAIM when set', async () => {+ // Arrange – set OPENID_USERNAME_CLAIM so that the sub claim is used+ process.env.OPENID_USERNAME_CLAIM = 'sub';+ const userinfo = { ...baseUserinfo };- await validateFn(tokenset, userinfo_modified, (err, user) => {- expect(err).toBe(null);- expect(user.name).toBe(expectName);- });- await expect(User.exists({ name: expectName })).resolves.not.toBeNull();- });+ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert – username should equal the sub (converted as-is)+ expect(user.username).toBe(userinfo.sub);+ expect(createUser).toHaveBeenCalledWith(+ expect.objectContaining({ username: userinfo.sub }),+ true,+ true,+ );+ });- it('should should update existing user after login', async () => {- const expectUsername = userinfo.username.toLowerCase();- await User.create(userModel);+ it('should set the full name correctly when given_name and family_name exist', async () => {+ // Arrange+ const userinfo = { ...baseUserinfo };+ const expectedFullName = `${userinfo.given_name} ${userinfo.family_name}`;- await validateFn(tokenset, userinfo, (err) => {- expect(err).toBe(null);- });- const newUser = await User.findOne({ openidId: userModel.openidId });- await expect(newUser.provider).toBe('openid');- await expect(newUser.username).toBe(expectUsername);- await expect(newUser.name).toBe(userinfo.given_name + ' ' + userinfo.family_name);+ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert+ expect(user.name).toBe(expectedFullName);+ });++ it('should override full name with OPENID_NAME_CLAIM when set', async () => {+ // Arrange – use the name claim as the full name+ process.env.OPENID_NAME_CLAIM = 'name';+ const userinfo = { ...baseUserinfo, name: 'Custom Name' };++ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert+ expect(user.name).toBe('Custom Name');+ });++ it('should update an existing user on login', async () => {+ // Arrange – simulate that a user already exists+ const existingUser = {+ _id: 'existingUserId',+ provider: 'local',+ email: baseUserinfo.email,+ openidId: '',+ username: '',+ name: '',+ };+ findUser.mockImplementation(async (query) => {+ if (query.openidId === baseUserinfo.sub || query.email === baseUserinfo.email) {+ return existingUser;+ }+ return null;});- it('should should enforce required role', async () => {- jwtDecode.mockReturnValue({- roles: ['SomeOtherRole'],- });- await validateFn(tokenset, userinfo, (err, user, details) => {- expect(err).toBe(null);- expect(user).toBe(false);- expect(details.message).toBe(- 'You must have the "' + process.env.OPENID_REQUIRED_ROLE + '" role to log in.',- );- });+ const userinfo = { ...baseUserinfo };++ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert – updateUser should be called and the user object updated+ expect(updateUser).toHaveBeenCalledWith(existingUser._id, expect.objectContaining({+ provider: 'openid',+ openidId: baseUserinfo.sub,+ username: baseUserinfo.username,+ name: `${baseUserinfo.given_name} ${baseUserinfo.family_name}`,+ }));+ });++ it('should enforce the required role and reject login if missing', async () => {+ // Arrange – simulate a token without the required role.+ jwtDecode.mockReturnValue({+ roles: ['SomeOtherRole'],});+ const userinfo = { ...baseUserinfo };++ // Act+ const { user, details } = await validate(tokenset, userinfo);++ // Assert – verify that the strategy rejects login+ expect(user).toBe(false);+ expect(details.message).toBe(+ 'You must have the "requiredRole" role to log in.',+ );});-});++ it('should attempt to download and save the avatar if picture is provided', async () => {+ // Arrange – ensure userinfo contains a picture URL+ const userinfo = { ...baseUserinfo };++ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert – verify that download was attempted and the avatar field was set via updateUser+ expect(fetch).toHaveBeenCalled();+ // Our mock getStrategyFunctions.saveBuffer returns '/fake/path/to/avatar.png'+ expect(user.avatar).toBe('/fake/path/to/avatar.png');+ });++ it('should not attempt to download avatar if picture is not provided', async () => {+ // Arrange – remove picture+ const userinfo = { ...baseUserinfo };+ delete userinfo.picture;++ // Act+ const { user } = await validate(tokenset, userinfo);++ // Assert – fetch should not be called and avatar should remain undefined or empty+ expect(fetch).not.toHaveBeenCalled();+ // Depending on your implementation, user.avatar may be undefined or an empty string.+ });+});\ No newline at end of file