@sync-in/server 1.3.9 → 1.4.0

package/server/authentication/services/auth-methods/auth-method-ldap.service.spec.js

@@ -7,29 +7,524 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _testing = require("@nestjs/testing");
+const _appconstants = require("../../../app.constants");
 const _adminusersmanagerservice = require("../../../applications/users/services/admin-users-manager.service");
 const _usersmanagerservice = require("../../../applications/users/services/users-manager.service");
 const _authmethodldapservice = require("./auth-method-ldap.service");
+const _configenvironment = require("../../../configuration/config.environment");
+const _ldapts = require("ldapts");
+const _functions = /*#__PURE__*/ _interop_require_wildcard(require("../../../common/functions"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// Mock ldapts Client to simulate LDAP behaviors
+jest.mock('ldapts', ()=>{
+    let InvalidCredentialsError = class InvalidCredentialsError extends Error {
+    };
+    const mockClientInstance = {
+        bind: jest.fn(),
+        search: jest.fn(),
+        unbind: jest.fn()
+    };
+    const Client = jest.fn().mockImplementation(()=>mockClientInstance);
+    return {
+        Client,
+        InvalidCredentialsError
+    };
+});
+// --- Test helpers (DRY) ---
+// Reusable LDAP mocks
+const mockBindResolve = (ldapClient)=>{
+    ldapClient.bind.mockResolvedValue(undefined);
+    ldapClient.unbind.mockResolvedValue(undefined);
+};
+const mockBindRejectInvalid = (ldapClient, InvalidCredentialsErrorCtor, message = 'invalid')=>{
+    ldapClient.bind.mockRejectedValue(new InvalidCredentialsErrorCtor(message));
+    ldapClient.unbind.mockResolvedValue(undefined);
+};
+const mockSearchEntries = (ldapClient, entries)=>{
+    ldapClient.search.mockResolvedValue({
+        searchEntries: entries
+    });
+};
+const mockSearchReject = (ldapClient, err)=>{
+    ldapClient.search.mockRejectedValue(err);
+};
+// User factory
+const buildUser = (overrides = {})=>({
+        id: 0,
+        login: 'john',
+        email: 'old@example.org',
+        password: 'hashed',
+        isGuest: false,
+        isActive: true,
+        makePaths: jest.fn().mockResolvedValue(undefined),
+        ...overrides
+    });
+// --------------------------
 describe(_authmethodldapservice.AuthMethodLdapService.name, ()=>{
-    let service;
+    let authMethodLdapService;
+    let usersManager;
+    let adminUsersManager;
+    const ldapClient = {
+        bind: jest.fn(),
+        search: jest.fn(),
+        unbind: jest.fn()
+    };
+    _ldapts.Client.mockImplementation(()=>ldapClient);
+    // Local helpers (need access to authMethodLdapService and ldapClient in this scope)
+    const setupLdapSuccess = (entries)=>{
+        mockBindResolve(ldapClient);
+        mockSearchEntries(ldapClient, entries);
+    };
+    const spyLoggerError = ()=>jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(()=>undefined);
     beforeAll(async ()=>{
         const module = await _testing.Test.createTestingModule({
             providers: [
                 _authmethodldapservice.AuthMethodLdapService,
                 {
                     provide: _usersmanagerservice.UsersManager,
-                    useValue: {}
+                    useValue: {
+                        findUser: jest.fn(),
+                        logUser: jest.fn(),
+                        updateAccesses: jest.fn().mockResolvedValue(undefined)
+                    }
                 },
                 {
                     provide: _adminusersmanagerservice.AdminUsersManager,
-                    useValue: {}
+                    useValue: {
+                        createUserOrGuest: jest.fn(),
+                        updateUserOrGuest: jest.fn()
+                    }
                 }
             ]
         }).compile();
-        service = module.get(_authmethodldapservice.AuthMethodLdapService);
+        module.useLogger([
+            'fatal'
+        ]);
+        authMethodLdapService = module.get(_authmethodldapservice.AuthMethodLdapService);
+        adminUsersManager = module.get(_adminusersmanagerservice.AdminUsersManager);
+        usersManager = module.get(_usersmanagerservice.UsersManager);
+        _configenvironment.configuration.auth.ldap = {
+            servers: [
+                'ldap://localhost:389'
+            ],
+            loginAttribute: 'uid',
+            baseDN: 'ou=people,dc=example,dc=org',
+            filter: ''
+        };
     });
     it('should be defined', ()=>{
-        expect(service).toBeDefined();
+        expect(authMethodLdapService).toBeDefined();
+        expect(usersManager).toBeDefined();
+        expect(adminUsersManager).toBeDefined();
+        expect(ldapClient).toBeDefined();
+    });
+    it('should authenticate a guest user via database and bypass LDAP', async ()=>{
+        // Arrange
+        const guestUser = {
+            id: 1,
+            login: 'guest1',
+            isGuest: true,
+            isActive: true
+        };
+        usersManager.findUser.mockResolvedValue(guestUser);
+        const dbAuthResult = {
+            ...guestUser,
+            token: 'jwt'
+        };
+        usersManager.logUser.mockResolvedValue(dbAuthResult);
+        const res = await authMethodLdapService.validateUser('guest1', 'pass', '127.0.0.1');
+        expect(res).toEqual(dbAuthResult);
+        expect(usersManager.logUser).toHaveBeenCalledWith(guestUser, 'pass', '127.0.0.1');
+        expect(_ldapts.Client).not.toHaveBeenCalled(); // client should not be constructed
+    });
+    it('should throw FORBIDDEN for locked account and LDAP login mismatch', async ()=>{
+        // Phase 1: locked account
+        usersManager.findUser.mockResolvedValue({
+            login: 'john',
+            isGuest: false,
+            isActive: false
+        });
+        const loggerErrorSpy1 = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(()=>undefined);
+        await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/account locked/i);
+        expect(loggerErrorSpy1).toHaveBeenCalled();
+        // Phase 2: mismatch between requested login and LDAP returned login
+        const existingUser = buildUser({
+            id: 8
+        });
+        usersManager.findUser.mockResolvedValue(existingUser);
+        const originalAttr = _configenvironment.configuration.auth.ldap.loginAttribute;
+        _configenvironment.configuration.auth.ldap.loginAttribute = 'cn';
+        mockBindResolve(ldapClient);
+        mockSearchEntries(ldapClient, [
+            {
+                uid: 'jane',
+                cn: 'john',
+                mail: 'jane@example.org'
+            }
+        ]);
+        await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/account matching error/i);
+        // restore the attribute to avoid impacting other tests
+        _configenvironment.configuration.auth.ldap.loginAttribute = originalAttr;
+    });
+    it('should handle invalid LDAP credentials for both existing and unknown users', async ()=>{
+        // Phase 1: existing user -> updateAccesses invoked with success=false and logger.error intercepted
+        const existingUser = buildUser({
+            id: 1
+        });
+        usersManager.findUser.mockResolvedValue(existingUser);
+        // Make LDAP bind throw InvalidCredentialsError
+        mockBindRejectInvalid(ldapClient, _ldapts.InvalidCredentialsError, 'invalid credentials');
+        // Force updateAccesses to reject to hit the catch and logger.error
+        const loggerErrorSpy = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(()=>undefined);
+        usersManager.updateAccesses.mockRejectedValueOnce(new Error('updateAccesses boom'));
+        const res1 = await authMethodLdapService.validateUser('john', 'badpwd', '10.0.0.1');
+        expect(res1).toBeNull();
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '10.0.0.1', false);
+        expect(loggerErrorSpy).toHaveBeenCalled();
+        // Phase 2: unknown user → no access update
+        usersManager.updateAccesses.mockClear();
+        usersManager.findUser.mockResolvedValue(null);
+        ldapClient.bind.mockRejectedValue(new _ldapts.InvalidCredentialsError('invalid'));
+        ldapClient.unbind.mockResolvedValue(undefined);
+        const res2 = await authMethodLdapService.validateUser('jane', 'badpwd');
+        expect(res2).toBeNull();
+        expect(usersManager.updateAccesses).not.toHaveBeenCalled();
+    });
+    it('should handle LDAP new-user flow: missing fields, creation success, and multi-email selection', async ()=>{
+        // Phase 1: incomplete LDAP entry -> null + error log, no creation
+        usersManager.findUser.mockResolvedValue(null);
+        mockBindResolve(ldapClient);
+        // Simulate an entry with missing mail
+        mockSearchEntries(ldapClient, [
+            {
+                uid: 'jane',
+                cn: 'Jane Doe',
+                mail: undefined
+            }
+        ]);
+        const loggerErrorSpy = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(()=>undefined);
+        const resA = await authMethodLdapService.validateUser('jane', 'pwd');
+        expect(resA).toBeNull();
+        expect(adminUsersManager.createUserOrGuest).not.toHaveBeenCalled();
+        expect(loggerErrorSpy).toHaveBeenCalled();
+        // Phase 2: create a new user (success, single email)
+        usersManager.findUser.mockResolvedValue(null);
+        setupLdapSuccess([
+            {
+                uid: 'john',
+                cn: 'John Doe',
+                mail: 'john@example.org'
+            }
+        ]);
+        const createdUser = {
+            id: 2,
+            login: 'john',
+            isGuest: false,
+            isActive: true,
+            makePaths: jest.fn()
+        };
+        adminUsersManager.createUserOrGuest.mockResolvedValue(createdUser);
+        // Cover the success-flow catch branch
+        const loggerErrorSpy2 = spyLoggerError();
+        usersManager.updateAccesses.mockRejectedValueOnce(new Error('updateAccesses success flow boom'));
+        const resB = await authMethodLdapService.validateUser('john', 'pwd', '192.168.1.10');
+        expect(adminUsersManager.createUserOrGuest).toHaveBeenCalledWith({
+            login: 'john',
+            email: 'john@example.org',
+            password: 'pwd',
+            firstName: 'John',
+            lastName: 'Doe'
+        }, expect.anything() // USER_ROLE.USER
+        );
+        expect(resB).toBe(createdUser);
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(createdUser, '192.168.1.10', true);
+        expect(loggerErrorSpy2).toHaveBeenCalled();
+        // Phase 3: multiple emails -> keep the first
+        usersManager.findUser.mockResolvedValue(null);
+        setupLdapSuccess([
+            {
+                uid: 'multi',
+                cn: 'Multi Mail',
+                mail: [
+                    'first@example.org',
+                    'second@example.org'
+                ]
+            }
+        ]);
+        const createdUser2 = {
+            id: 9,
+            login: 'multi',
+            makePaths: jest.fn()
+        };
+        adminUsersManager.createUserOrGuest.mockResolvedValue(createdUser2);
+        const resC = await authMethodLdapService.validateUser('multi', 'pwd');
+        expect(adminUsersManager.createUserOrGuest).toHaveBeenCalledWith(expect.objectContaining({
+            email: 'first@example.org'
+        }), expect.anything());
+        expect(resC).toBe(createdUser2);
+    });
+    it('should update existing user profile when LDAP identity changed (except password assigned back)', async ()=>{
+        // Arrange: existing user with different profile and an old password
+        const existingUser = buildUser({
+            id: 5
+        });
+        usersManager.findUser.mockResolvedValue(existingUser);
+        // LDAP succeeds and returns different email and same uid
+        setupLdapSuccess([
+            {
+                uid: 'john',
+                cn: 'John Doe',
+                mail: 'john@example.org'
+            }
+        ]);
+        // Admin manager successfully updates a user
+        adminUsersManager.updateUserOrGuest.mockResolvedValue(undefined);
+        // Ensure password is considered changed so the update payload includes it,
+        // which then triggers the deletion and local assignment branches after update
+        const compareSpy = jest.spyOn(_functions, 'comparePassword').mockResolvedValue(false);
+        const res = await authMethodLdapService.validateUser('john', 'new-plain-password', '127.0.0.2');
+        expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalledWith(5, expect.objectContaining({
+            email: 'john@example.org',
+            firstName: 'John',
+            lastName: 'Doe'
+        }));
+        // Password should not be assigned back onto the user object (it is deleted before Object.assign)
+        expect(existingUser.password).toBe('hashed');
+        // Other fields should be updated locally
+        expect(existingUser.email).toBe('john@example.org');
+        expect(existingUser).toMatchObject({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        // Accesses updated as success
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.2', true);
+        // Returned user is the same instance
+        expect(res).toBe(existingUser);
+        // Second run: password unchanged (comparePassword => true) to cover the null branch for password
+        adminUsersManager.updateUserOrGuest.mockClear();
+        usersManager.updateAccesses.mockClear();
+        // Force another non-password change so an update occurs
+        existingUser.email = 'old@example.org';
+        compareSpy.mockResolvedValue(true);
+        const res2 = await authMethodLdapService.validateUser('john', 'same-plain-password', '127.0.0.3');
+        // Update should be called without password, only with changed fields
+        expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalled();
+        const updateArgs = adminUsersManager.updateUserOrGuest.mock.calls[0];
+        expect(updateArgs[0]).toBe(5);
+        expect(updateArgs[1]).toEqual(expect.objectContaining({
+            email: 'john@example.org'
+        }));
+        expect(updateArgs[1]).toEqual(expect.not.objectContaining({
+            password: expect.anything()
+        }));
+        // Password remains unchanged locally
+        expect(existingUser.password).toBe('hashed');
+        // Accesses updated as success
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.3', true);
+        // Returned user is the same instance
+        expect(res2).toBe(existingUser);
+        // Third run: no changes at all (identityHasChanged is empty) to cover the else branch
+        adminUsersManager.updateUserOrGuest.mockClear();
+        usersManager.updateAccesses.mockClear();
+        compareSpy.mockResolvedValue(true);
+        // Local user already matches LDAP identity; call again
+        const res3 = await authMethodLdapService.validateUser('john', 'same-plain-password', '127.0.0.4');
+        // No update should be triggered
+        expect(adminUsersManager.updateUserOrGuest).not.toHaveBeenCalled();
+        // Access should still be updated as success
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.4', true);
+        // Returned user is the same instance
+        expect(res3).toBe(existingUser);
+    });
+    it('should log failed access when LDAP search returns no entry or throws after bind', async ()=>{
+        // Phase 1: no entry found after a successful bind -> failed access
+        const existingUser = {
+            id: 7,
+            login: 'ghost',
+            isGuest: false,
+            isActive: true
+        };
+        usersManager.findUser.mockResolvedValue(existingUser);
+        setupLdapSuccess([]);
+        const resA = await authMethodLdapService.validateUser('ghost', 'pwd', '10.10.0.1');
+        expect(resA).toBeNull();
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '10.10.0.1', false);
+        // Phase 2: exception during search after a bind -> failed access
+        jest.clearAllMocks();
+        const existingUser2 = {
+            id: 10,
+            login: 'john',
+            isGuest: false,
+            isActive: true
+        };
+        usersManager.findUser.mockResolvedValue(existingUser2);
+        mockBindResolve(ldapClient);
+        mockSearchReject(ldapClient, new Error('search failed'));
+        const resB = await authMethodLdapService.validateUser('john', 'pwd', '1.1.1.1');
+        expect(resB).toBeNull();
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser2, '1.1.1.1', false);
+    });
+    it('should throw 500 when LDAP connection error occurs during bind', async ()=>{
+        // Arrange: no existing user to reach checkAuth flow
+        usersManager.findUser.mockResolvedValue(null);
+        const err1 = new Error('socket hang up');
+        const err2 = Object.assign(new Error('connect ECONNREFUSED'), {
+            code: Array.from(_appconstants.CONNECT_ERROR_CODE)[0]
+        });
+        ldapClient.bind.mockRejectedValue({
+            errors: [
+                err1,
+                err2
+            ]
+        });
+        ldapClient.unbind.mockResolvedValue(undefined);
+        // First scenario: recognized connection error -> throws 500
+        await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/authentication service/i);
+        // Second scenario: generic error (no code, not InvalidCredentialsError) -> resolves to null and no access update
+        ldapClient.bind.mockReset();
+        ldapClient.unbind.mockReset();
+        usersManager.updateAccesses.mockClear();
+        usersManager.findUser.mockResolvedValue(null);
+        ldapClient.bind.mockRejectedValue(new Error('unexpected failure'));
+        ldapClient.unbind.mockResolvedValue(undefined);
+        const res = await authMethodLdapService.validateUser('john', 'pwd');
+        expect(res).toBeNull();
+        expect(usersManager.updateAccesses).not.toHaveBeenCalled();
+    });
+    it('should log update failure and still call makePaths when updating existing user', async ()=>{
+        // Arrange: existing user with changed identity
+        const existingUser = buildUser({
+            id: 11,
+            email: 'old@ex.org'
+        });
+        usersManager.findUser.mockResolvedValue(existingUser);
+        // Ensure LDAP loginAttribute matches uid for this test (a previous test sets it to 'cn')
+        _configenvironment.configuration.auth.ldap.loginAttribute = 'uid';
+        setupLdapSuccess([
+            {
+                uid: 'john',
+                cn: 'John Doe',
+                mail: 'john@example.org'
+            }
+        ]);
+        adminUsersManager.updateUserOrGuest.mockRejectedValue(new Error('db error'));
+        // Force identity to be considered changed only for this test
+        jest.spyOn(_functions, 'comparePassword').mockResolvedValue(false);
+        jest.spyOn(_functions, 'splitFullName').mockReturnValue({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        const res = await authMethodLdapService.validateUser('john', 'pwd');
+        expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalled();
+        // makePaths still invoked
+        expect(existingUser.makePaths).toHaveBeenCalled();
+        // Local fields unchanged since update failed
+        expect(existingUser.email).toBe('old@ex.org');
+        expect(res).toBe(existingUser);
+    });
+    it('should skip non-matching LDAP entries then update user with changed password without reassigning it', async ()=>{
+        // Phase A: LDAP returns an entry but loginAttribute value does not match -> checkAccess returns false (covers return after loop)
+        const userA = {
+            id: 20,
+            login: 'john',
+            isGuest: false,
+            isActive: true
+        };
+        usersManager.findUser.mockResolvedValue(userA);
+        _configenvironment.configuration.auth.ldap.loginAttribute = 'uid';
+        ldapClient.bind.mockResolvedValue(undefined);
+        // Non-matching entry: uid !== requested uid
+        ldapClient.search.mockResolvedValue({
+            searchEntries: [
+                {
+                    uid: 'jane',
+                    cn: 'Jane Doe',
+                    mail: 'jane@example.org'
+                }
+            ]
+        });
+        ldapClient.unbind.mockResolvedValue(undefined);
+        const resA = await authMethodLdapService.validateUser('john', 'pwd', '3.3.3.3');
+        expect(resA).toBeNull();
+        expect(usersManager.updateAccesses).toHaveBeenCalledWith(userA, '3.3.3.3', false);
+        // Phase B: Matching entry + password considered changed -> updateUserOrGuest called, password not reassigned locally
+        jest.clearAllMocks();
+        const userB = buildUser({
+            id: 21,
+            email: 'old@ex.org'
+        });
+        usersManager.findUser.mockResolvedValue(userB);
+        _configenvironment.configuration.auth.ldap.loginAttribute = 'uid';
+        setupLdapSuccess([
+            {
+                uid: 'john',
+                cn: 'John Doe',
+                mail: 'john@example.org'
+            }
+        ]);
+        adminUsersManager.updateUserOrGuest.mockResolvedValue(undefined);
+        // Force password to be considered changed to execute deletion + Object.assign branch
+        jest.spyOn(_functions, 'comparePassword').mockResolvedValue(false);
+        jest.spyOn(_functions, 'splitFullName').mockReturnValue({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        const resB = await authMethodLdapService.validateUser('john', 'newpwd', '4.4.4.4');
+        // Line 132: updateUserOrGuest call
+        expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalledWith(21, expect.objectContaining({
+            email: 'john@example.org',
+            firstName: 'John',
+            lastName: 'Doe'
+        }));
+        // Lines 139-142: password removed from local assign, other fields assigned
+        expect(userB.password).toBe('hashed');
+        expect(userB.email).toBe('john@example.org');
+        expect(userB).toMatchObject({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        expect(userB.makePaths).toHaveBeenCalled();
+        expect(resB).toBe(userB);
     });
 });
 

package/server/authentication/services/auth-methods/auth-method-ldap.service.spec.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../backend/src/authentication/services/auth-methods/auth-method-ldap.service.spec.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { Test, TestingModule } from '@nestjs/testing'\nimport { AdminUsersManager } from '../../../applications/users/services/admin-users-manager.service'\nimport { UsersManager } from '../../../applications/users/services/users-manager.service'\nimport { AuthMethodLdapService } from './auth-method-ldap.service'\n\ndescribe(AuthMethodLdapService.name, () => {\n  let service: AuthMethodLdapService\n\n  beforeAll(async () => {\n    const module: TestingModule = await Test.createTestingModule({\n      providers: [AuthMethodLdapService, { provide: UsersManager, useValue: {} }, { provide: AdminUsersManager, useValue: {} }]\n    }).compile()\n\n    service = module.get<AuthMethodLdapService>(AuthMethodLdapService)\n  })\n\n  it('should be defined', () => {\n    expect(service).toBeDefined()\n  })\n})\n"],"names":["describe","AuthMethodLdapService","name","service","beforeAll","module","Test","createTestingModule","providers","provide","UsersManager","useValue","AdminUsersManager","compile","get","it","expect","toBeDefined"],"mappings":"AAAA;;;;CAIC;;;;yBAEmC;0CACF;qCACL;uCACS;AAEtCA,SAASC,4CAAqB,CAACC,IAAI,EAAE;IACnC,IAAIC;IAEJC,UAAU;QACR,MAAMC,SAAwB,MAAMC,aAAI,CAACC,mBAAmB,CAAC;YAC3DC,WAAW;gBAACP,4CAAqB;gBAAE;oBAAEQ,SAASC,iCAAY;oBAAEC,UAAU,CAAC;gBAAE;gBAAG;oBAAEF,SAASG,2CAAiB;oBAAED,UAAU,CAAC;gBAAE;aAAE;QAC3H,GAAGE,OAAO;QAEVV,UAAUE,OAAOS,GAAG,CAAwBb,4CAAqB;IACnE;IAEAc,GAAG,qBAAqB;QACtBC,OAAOb,SAASc,WAAW;IAC7B;AACF"}
+{"version":3,"sources":["../../../../../backend/src/authentication/services/auth-methods/auth-method-ldap.service.spec.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { Test, TestingModule } from '@nestjs/testing'\nimport { CONNECT_ERROR_CODE } from '../../../app.constants'\nimport { UserModel } from '../../../applications/users/models/user.model'\nimport { AdminUsersManager } from '../../../applications/users/services/admin-users-manager.service'\nimport { UsersManager } from '../../../applications/users/services/users-manager.service'\nimport { AuthMethodLdapService } from './auth-method-ldap.service'\nimport { configuration } from '../../../configuration/config.environment'\nimport { Client, InvalidCredentialsError } from 'ldapts'\nimport { Mocked } from 'jest-mock'\nimport * as commonFunctions from '../../../common/functions'\n\n// Mock ldapts Client to simulate LDAP behaviors\njest.mock('ldapts', () => {\n  class InvalidCredentialsError extends Error {}\n  const mockClientInstance = {\n    bind: jest.fn(),\n    search: jest.fn(),\n    unbind: jest.fn()\n  }\n  const Client = jest.fn().mockImplementation(() => mockClientInstance)\n  return { Client, InvalidCredentialsError }\n})\n\n// --- Test helpers (DRY) ---\n// Reusable LDAP mocks\nconst mockBindResolve = (ldapClient: any) => {\n  ldapClient.bind.mockResolvedValue(undefined)\n  ldapClient.unbind.mockResolvedValue(undefined)\n}\nconst mockBindRejectInvalid = (ldapClient: any, InvalidCredentialsErrorCtor: any, message = 'invalid') => {\n  ldapClient.bind.mockRejectedValue(new InvalidCredentialsErrorCtor(message))\n  ldapClient.unbind.mockResolvedValue(undefined)\n}\nconst mockSearchEntries = (ldapClient: any, entries: any[]) => {\n  ldapClient.search.mockResolvedValue({ searchEntries: entries })\n}\nconst mockSearchReject = (ldapClient: any, err: Error) => {\n  ldapClient.search.mockRejectedValue(err)\n}\n// User factory\nconst buildUser = (overrides: Partial<UserModel> = {}) =>\n  ({\n    id: 0,\n    login: 'john',\n    email: 'old@example.org',\n    password: 'hashed',\n    isGuest: false,\n    isActive: true,\n    makePaths: jest.fn().mockResolvedValue(undefined),\n    ...overrides\n  }) as any\n\n// --------------------------\n\ndescribe(AuthMethodLdapService.name, () => {\n  let authMethodLdapService: AuthMethodLdapService\n  let usersManager: Mocked<UsersManager>\n  let adminUsersManager: Mocked<AdminUsersManager>\n  const ldapClient = {\n    bind: jest.fn(),\n    search: jest.fn(),\n    unbind: jest.fn()\n  }\n  ;(Client as Mocked<any>).mockImplementation(() => ldapClient)\n\n  // Local helpers (need access to authMethodLdapService and ldapClient in this scope)\n  const setupLdapSuccess = (entries: any[]) => {\n    mockBindResolve(ldapClient)\n    mockSearchEntries(ldapClient, entries)\n  }\n  const spyLoggerError = () => jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(() => undefined as any)\n\n  beforeAll(async () => {\n    const module: TestingModule = await Test.createTestingModule({\n      providers: [\n        AuthMethodLdapService,\n        {\n          provide: UsersManager,\n          useValue: {\n            findUser: jest.fn(),\n            logUser: jest.fn(),\n            updateAccesses: jest.fn().mockResolvedValue(undefined)\n          }\n        },\n        {\n          provide: AdminUsersManager,\n          useValue: {\n            createUserOrGuest: jest.fn(),\n            updateUserOrGuest: jest.fn()\n          }\n        }\n      ]\n    }).compile()\n\n    module.useLogger(['fatal'])\n    authMethodLdapService = module.get<AuthMethodLdapService>(AuthMethodLdapService)\n    adminUsersManager = module.get<Mocked<AdminUsersManager>>(AdminUsersManager)\n    usersManager = module.get<Mocked<UsersManager>>(UsersManager)\n    configuration.auth.ldap = { servers: ['ldap://localhost:389'], loginAttribute: 'uid', baseDN: 'ou=people,dc=example,dc=org', filter: '' }\n  })\n\n  it('should be defined', () => {\n    expect(authMethodLdapService).toBeDefined()\n    expect(usersManager).toBeDefined()\n    expect(adminUsersManager).toBeDefined()\n    expect(ldapClient).toBeDefined()\n  })\n\n  it('should authenticate a guest user via database and bypass LDAP', async () => {\n    // Arrange\n    const guestUser: any = { id: 1, login: 'guest1', isGuest: true, isActive: true }\n    usersManager.findUser.mockResolvedValue(guestUser)\n    const dbAuthResult: any = { ...guestUser, token: 'jwt' }\n    usersManager.logUser.mockResolvedValue(dbAuthResult)\n\n    const res = await authMethodLdapService.validateUser('guest1', 'pass', '127.0.0.1')\n\n    expect(res).toEqual(dbAuthResult)\n    expect(usersManager.logUser).toHaveBeenCalledWith(guestUser, 'pass', '127.0.0.1')\n    expect(Client).not.toHaveBeenCalled() // client should not be constructed\n  })\n\n  it('should throw FORBIDDEN for locked account and LDAP login mismatch', async () => {\n    // Phase 1: locked account\n    usersManager.findUser.mockResolvedValue({ login: 'john', isGuest: false, isActive: false } as UserModel)\n    const loggerErrorSpy1 = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(() => undefined as any)\n\n    await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/account locked/i)\n    expect(loggerErrorSpy1).toHaveBeenCalled()\n\n    // Phase 2: mismatch between requested login and LDAP returned login\n    const existingUser: any = buildUser({ id: 8 })\n    usersManager.findUser.mockResolvedValue(existingUser)\n    const originalAttr = configuration.auth.ldap.loginAttribute\n    configuration.auth.ldap.loginAttribute = 'cn'\n    mockBindResolve(ldapClient)\n    mockSearchEntries(ldapClient, [{ uid: 'jane', cn: 'john', mail: 'jane@example.org' }])\n\n    await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/account matching error/i)\n\n    // restore the attribute to avoid impacting other tests\n    configuration.auth.ldap.loginAttribute = originalAttr\n  })\n\n  it('should handle invalid LDAP credentials for both existing and unknown users', async () => {\n    // Phase 1: existing user -> updateAccesses invoked with success=false and logger.error intercepted\n    const existingUser: any = buildUser({ id: 1 })\n    usersManager.findUser.mockResolvedValue(existingUser)\n    // Make LDAP bind throw InvalidCredentialsError\n    mockBindRejectInvalid(ldapClient, InvalidCredentialsError, 'invalid credentials')\n    // Force updateAccesses to reject to hit the catch and logger.error\n    const loggerErrorSpy = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(() => undefined as any)\n    usersManager.updateAccesses.mockRejectedValueOnce(new Error('updateAccesses boom'))\n\n    const res1 = await authMethodLdapService.validateUser('john', 'badpwd', '10.0.0.1')\n\n    expect(res1).toBeNull()\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '10.0.0.1', false)\n    expect(loggerErrorSpy).toHaveBeenCalled()\n\n    // Phase 2: unknown user → no access update\n    usersManager.updateAccesses.mockClear()\n    usersManager.findUser.mockResolvedValue(null)\n    ldapClient.bind.mockRejectedValue(new InvalidCredentialsError('invalid'))\n    ldapClient.unbind.mockResolvedValue(undefined)\n\n    const res2 = await authMethodLdapService.validateUser('jane', 'badpwd')\n\n    expect(res2).toBeNull()\n    expect(usersManager.updateAccesses).not.toHaveBeenCalled()\n  })\n\n  it('should handle LDAP new-user flow: missing fields, creation success, and multi-email selection', async () => {\n    // Phase 1: incomplete LDAP entry -> null + error log, no creation\n    usersManager.findUser.mockResolvedValue(null)\n    mockBindResolve(ldapClient)\n    // Simulate an entry with missing mail\n    mockSearchEntries(ldapClient, [{ uid: 'jane', cn: 'Jane Doe', mail: undefined }])\n    const loggerErrorSpy = jest.spyOn(authMethodLdapService['logger'], 'error').mockImplementation(() => undefined as any)\n\n    const resA = await authMethodLdapService.validateUser('jane', 'pwd')\n\n    expect(resA).toBeNull()\n    expect(adminUsersManager.createUserOrGuest).not.toHaveBeenCalled()\n    expect(loggerErrorSpy).toHaveBeenCalled()\n\n    // Phase 2: create a new user (success, single email)\n    usersManager.findUser.mockResolvedValue(null)\n    setupLdapSuccess([{ uid: 'john', cn: 'John Doe', mail: 'john@example.org' }])\n\n    const createdUser: any = { id: 2, login: 'john', isGuest: false, isActive: true, makePaths: jest.fn() }\n    adminUsersManager.createUserOrGuest.mockResolvedValue(createdUser)\n    // Cover the success-flow catch branch\n    const loggerErrorSpy2 = spyLoggerError()\n    usersManager.updateAccesses.mockRejectedValueOnce(new Error('updateAccesses success flow boom'))\n\n    const resB = await authMethodLdapService.validateUser('john', 'pwd', '192.168.1.10')\n\n    expect(adminUsersManager.createUserOrGuest).toHaveBeenCalledWith(\n      { login: 'john', email: 'john@example.org', password: 'pwd', firstName: 'John', lastName: 'Doe' },\n      expect.anything() // USER_ROLE.USER\n    )\n    expect(resB).toBe(createdUser)\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(createdUser, '192.168.1.10', true)\n    expect(loggerErrorSpy2).toHaveBeenCalled()\n\n    // Phase 3: multiple emails -> keep the first\n    usersManager.findUser.mockResolvedValue(null)\n    setupLdapSuccess([{ uid: 'multi', cn: 'Multi Mail', mail: ['first@example.org', 'second@example.org'] }])\n\n    const createdUser2: any = { id: 9, login: 'multi', makePaths: jest.fn() }\n    adminUsersManager.createUserOrGuest.mockResolvedValue(createdUser2)\n\n    const resC = await authMethodLdapService.validateUser('multi', 'pwd')\n\n    expect(adminUsersManager.createUserOrGuest).toHaveBeenCalledWith(expect.objectContaining({ email: 'first@example.org' }), expect.anything())\n    expect(resC).toBe(createdUser2)\n  })\n\n  it('should update existing user profile when LDAP identity changed (except password assigned back)', async () => {\n    // Arrange: existing user with different profile and an old password\n    const existingUser: any = buildUser({ id: 5 })\n    usersManager.findUser.mockResolvedValue(existingUser)\n\n    // LDAP succeeds and returns different email and same uid\n    setupLdapSuccess([{ uid: 'john', cn: 'John Doe', mail: 'john@example.org' }])\n\n    // Admin manager successfully updates a user\n    adminUsersManager.updateUserOrGuest.mockResolvedValue(undefined)\n\n    // Ensure password is considered changed so the update payload includes it,\n    // which then triggers the deletion and local assignment branches after update\n    const compareSpy = jest.spyOn(commonFunctions, 'comparePassword').mockResolvedValue(false)\n\n    const res = await authMethodLdapService.validateUser('john', 'new-plain-password', '127.0.0.2')\n\n    expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalledWith(\n      5,\n      expect.objectContaining({\n        email: 'john@example.org',\n        firstName: 'John',\n        lastName: 'Doe'\n      })\n    )\n    // Password should not be assigned back onto the user object (it is deleted before Object.assign)\n    expect(existingUser.password).toBe('hashed')\n    // Other fields should be updated locally\n    expect(existingUser.email).toBe('john@example.org')\n    expect(existingUser).toMatchObject({ firstName: 'John', lastName: 'Doe' })\n    // Accesses updated as success\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.2', true)\n    // Returned user is the same instance\n    expect(res).toBe(existingUser)\n\n    // Second run: password unchanged (comparePassword => true) to cover the null branch for password\n    adminUsersManager.updateUserOrGuest.mockClear()\n    usersManager.updateAccesses.mockClear()\n    // Force another non-password change so an update occurs\n    existingUser.email = 'old@example.org'\n    compareSpy.mockResolvedValue(true)\n\n    const res2 = await authMethodLdapService.validateUser('john', 'same-plain-password', '127.0.0.3')\n\n    // Update should be called without password, only with changed fields\n    expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalled()\n    const updateArgs = adminUsersManager.updateUserOrGuest.mock.calls[0]\n    expect(updateArgs[0]).toBe(5)\n    expect(updateArgs[1]).toEqual(\n      expect.objectContaining({\n        email: 'john@example.org'\n      })\n    )\n    expect(updateArgs[1]).toEqual(expect.not.objectContaining({ password: expect.anything() }))\n\n    // Password remains unchanged locally\n    expect(existingUser.password).toBe('hashed')\n    // Accesses updated as success\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.3', true)\n    // Returned user is the same instance\n    expect(res2).toBe(existingUser)\n\n    // Third run: no changes at all (identityHasChanged is empty) to cover the else branch\n    adminUsersManager.updateUserOrGuest.mockClear()\n    usersManager.updateAccesses.mockClear()\n    compareSpy.mockResolvedValue(true)\n\n    // Local user already matches LDAP identity; call again\n    const res3 = await authMethodLdapService.validateUser('john', 'same-plain-password', '127.0.0.4')\n\n    // No update should be triggered\n    expect(adminUsersManager.updateUserOrGuest).not.toHaveBeenCalled()\n    // Access should still be updated as success\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '127.0.0.4', true)\n    // Returned user is the same instance\n    expect(res3).toBe(existingUser)\n  })\n\n  it('should log failed access when LDAP search returns no entry or throws after bind', async () => {\n    // Phase 1: no entry found after a successful bind -> failed access\n    const existingUser: any = { id: 7, login: 'ghost', isGuest: false, isActive: true }\n    usersManager.findUser.mockResolvedValue(existingUser)\n    setupLdapSuccess([])\n\n    const resA = await authMethodLdapService.validateUser('ghost', 'pwd', '10.10.0.1')\n\n    expect(resA).toBeNull()\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser, '10.10.0.1', false)\n\n    // Phase 2: exception during search after a bind -> failed access\n    jest.clearAllMocks()\n    const existingUser2: any = { id: 10, login: 'john', isGuest: false, isActive: true }\n    usersManager.findUser.mockResolvedValue(existingUser2)\n    mockBindResolve(ldapClient)\n    mockSearchReject(ldapClient, new Error('search failed'))\n\n    const resB = await authMethodLdapService.validateUser('john', 'pwd', '1.1.1.1')\n\n    expect(resB).toBeNull()\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(existingUser2, '1.1.1.1', false)\n  })\n\n  it('should throw 500 when LDAP connection error occurs during bind', async () => {\n    // Arrange: no existing user to reach checkAuth flow\n    usersManager.findUser.mockResolvedValue(null)\n    const err1 = new Error('socket hang up')\n    const err2 = Object.assign(new Error('connect ECONNREFUSED'), { code: Array.from(CONNECT_ERROR_CODE)[0] })\n    ldapClient.bind.mockRejectedValue({ errors: [err1, err2] })\n    ldapClient.unbind.mockResolvedValue(undefined)\n\n    // First scenario: recognized connection error -> throws 500\n    await expect(authMethodLdapService.validateUser('john', 'pwd')).rejects.toThrow(/authentication service/i)\n\n    // Second scenario: generic error (no code, not InvalidCredentialsError) -> resolves to null and no access update\n    ldapClient.bind.mockReset()\n    ldapClient.unbind.mockReset()\n    usersManager.updateAccesses.mockClear()\n    usersManager.findUser.mockResolvedValue(null as any)\n    ldapClient.bind.mockRejectedValue(new Error('unexpected failure'))\n    ldapClient.unbind.mockResolvedValue(undefined)\n\n    const res = await authMethodLdapService.validateUser('john', 'pwd')\n    expect(res).toBeNull()\n    expect(usersManager.updateAccesses).not.toHaveBeenCalled()\n  })\n\n  it('should log update failure and still call makePaths when updating existing user', async () => {\n    // Arrange: existing user with changed identity\n    const existingUser: any = buildUser({ id: 11, email: 'old@ex.org' })\n    usersManager.findUser.mockResolvedValue(existingUser)\n\n    // Ensure LDAP loginAttribute matches uid for this test (a previous test sets it to 'cn')\n    configuration.auth.ldap.loginAttribute = 'uid'\n\n    setupLdapSuccess([{ uid: 'john', cn: 'John Doe', mail: 'john@example.org' }])\n    adminUsersManager.updateUserOrGuest.mockRejectedValue(new Error('db error'))\n\n    // Force identity to be considered changed only for this test\n    jest.spyOn(commonFunctions, 'comparePassword').mockResolvedValue(false)\n    jest.spyOn(commonFunctions, 'splitFullName').mockReturnValue({ firstName: 'John', lastName: 'Doe' })\n\n    const res = await authMethodLdapService.validateUser('john', 'pwd')\n\n    expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalled()\n    // makePaths still invoked\n    expect(existingUser.makePaths).toHaveBeenCalled()\n    // Local fields unchanged since update failed\n    expect(existingUser.email).toBe('old@ex.org')\n    expect(res).toBe(existingUser)\n  })\n\n  it('should skip non-matching LDAP entries then update user with changed password without reassigning it', async () => {\n    // Phase A: LDAP returns an entry but loginAttribute value does not match -> checkAccess returns false (covers return after loop)\n    const userA: any = { id: 20, login: 'john', isGuest: false, isActive: true }\n    usersManager.findUser.mockResolvedValue(userA)\n    configuration.auth.ldap.loginAttribute = 'uid'\n    ldapClient.bind.mockResolvedValue(undefined)\n    // Non-matching entry: uid !== requested uid\n    ldapClient.search.mockResolvedValue({ searchEntries: [{ uid: 'jane', cn: 'Jane Doe', mail: 'jane@example.org' }] })\n    ldapClient.unbind.mockResolvedValue(undefined)\n\n    const resA = await authMethodLdapService.validateUser('john', 'pwd', '3.3.3.3')\n    expect(resA).toBeNull()\n    expect(usersManager.updateAccesses).toHaveBeenCalledWith(userA, '3.3.3.3', false)\n\n    // Phase B: Matching entry + password considered changed -> updateUserOrGuest called, password not reassigned locally\n    jest.clearAllMocks()\n    const userB: any = buildUser({ id: 21, email: 'old@ex.org' })\n    usersManager.findUser.mockResolvedValue(userB)\n    configuration.auth.ldap.loginAttribute = 'uid'\n    setupLdapSuccess([{ uid: 'john', cn: 'John Doe', mail: 'john@example.org' }])\n    adminUsersManager.updateUserOrGuest.mockResolvedValue(undefined)\n\n    // Force password to be considered changed to execute deletion + Object.assign branch\n    jest.spyOn(commonFunctions, 'comparePassword').mockResolvedValue(false)\n    jest.spyOn(commonFunctions, 'splitFullName').mockReturnValue({ firstName: 'John', lastName: 'Doe' })\n\n    const resB = await authMethodLdapService.validateUser('john', 'newpwd', '4.4.4.4')\n\n    // Line 132: updateUserOrGuest call\n    expect(adminUsersManager.updateUserOrGuest).toHaveBeenCalledWith(\n      21,\n      expect.objectContaining({ email: 'john@example.org', firstName: 'John', lastName: 'Doe' })\n    )\n    // Lines 139-142: password removed from local assign, other fields assigned\n    expect(userB.password).toBe('hashed')\n    expect(userB.email).toBe('john@example.org')\n    expect(userB).toMatchObject({ firstName: 'John', lastName: 'Doe' })\n    expect(userB.makePaths).toHaveBeenCalled()\n    expect(resB).toBe(userB)\n  })\n})\n"],"names":["jest","mock","InvalidCredentialsError","Error","mockClientInstance","bind","fn","search","unbind","Client","mockImplementation","mockBindResolve","ldapClient","mockResolvedValue","undefined","mockBindRejectInvalid","InvalidCredentialsErrorCtor","message","mockRejectedValue","mockSearchEntries","entries","searchEntries","mockSearchReject","err","buildUser","overrides","id","login","email","password","isGuest","isActive","makePaths","describe","AuthMethodLdapService","name","authMethodLdapService","usersManager","adminUsersManager","setupLdapSuccess","spyLoggerError","spyOn","beforeAll","module","Test","createTestingModule","providers","provide","UsersManager","useValue","findUser","logUser","updateAccesses","AdminUsersManager","createUserOrGuest","updateUserOrGuest","compile","useLogger","get","configuration","auth","ldap","servers","loginAttribute","baseDN","filter","it","expect","toBeDefined","guestUser","dbAuthResult","token","res","validateUser","toEqual","toHaveBeenCalledWith","not","toHaveBeenCalled","loggerErrorSpy1","rejects","toThrow","existingUser","originalAttr","uid","cn","mail","loggerErrorSpy","mockRejectedValueOnce","res1","toBeNull","mockClear","res2","resA","createdUser","loggerErrorSpy2","resB","firstName","lastName","anything","toBe","createdUser2","resC","objectContaining","compareSpy","commonFunctions","toMatchObject","updateArgs","calls","res3","clearAllMocks","existingUser2","err1","err2","Object","assign","code","Array","from","CONNECT_ERROR_CODE","errors","mockReset","mockReturnValue","userA","userB"],"mappings":"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"}

package/server/configuration/config.loader.js

@@ -101,9 +101,6 @@ function loadEnvFile(envPath, envFileName, throwIfMissing = false) {
     ];
     for (const envFilePath of candidates){
         if (_nodefs.default.existsSync(envFilePath) && _nodefs.default.lstatSync(envFilePath).isFile()) {
-            if (envFileName === _configconstants.ENVIRONMENT_FILE_NAME) {
-                console.log(`Load configuration → ${envFilePath}`);
-            }
             return _jsyaml.load(_nodefs.default.readFileSync(envFilePath, 'utf8'));
         }
     }