@sync-in/server 1.9.6 → 1.10.0

package/server/applications/webdav/services/webdav-methods.service.spec.js

@@ -8,6 +8,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 const _common = require("@nestjs/common");
 const _testing = require("@nestjs/testing");
+const _fileerror = require("../../files/models/file-error");
+const _filelockerror = require("../../files/models/file-lock-error");
 const _fileslockmanagerservice = require("../../files/services/files-lock-manager.service");
 const _filesmanagerservice = require("../../files/services/files-manager.service");
 const _files = require("../../files/utils/files");
@@ -59,10 +61,13 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+// Mock external dependencies
 jest.mock('../../files/utils/files', ()=>({
-        isPathExists: jest.fn(),
+        isPathExists: jest.fn().mockReturnValue(false),
+        isPathIsDir: jest.fn(),
+        fileName: jest.fn().mockReturnValue('fileName'),
         dirName: jest.fn(),
-        genEtag: jest.fn().mockReturnValue('W/"etag"')
+        genEtag: jest.fn().mockReturnValue('W/"etag-123"')
     }));
 jest.mock('../../spaces/utils/permissions', ()=>({
         haveSpaceEnvPermissions: jest.fn()
@@ -77,12 +82,13 @@ jest.mock('../../spaces/utils/paths', ()=>{
 jest.mock('../decorators/if-header.decorator', ()=>({
         IfHeaderDecorator: ()=>(_target, _key, _desc)=>undefined
     }));
-describe(_webdavmethodsservice.WebDAVMethods.name, ()=>{
+describe('WebDAVMethods', ()=>{
     let service;
     let filesManager;
     let filesLockManager;
     let webDAVSpaces;
-    const makeRes = ()=>{
+    // Helper to create a mocked response object
+    const createMockResponse = ()=>{
         const res = {
             statusCode: undefined,
             body: undefined,
@@ -107,56 +113,64 @@ describe(_webdavmethodsservice.WebDAVMethods.name, ()=>{
         };
         return res;
     };
-    const baseReq = (overrides = {})=>({
+    // Helper to create a base request object
+    const createBaseRequest = (overrides = {})=>({
             method: 'GET',
             user: {
                 id: 1,
-                login: 'user-1'
+                login: 'test-user',
+                fullName: 'Test User',
+                email: 'test-user@sync-in.com'
             },
             dav: {
-                url: '/webdav/url',
+                url: '/webdav/test/file.txt',
                 depth: '0',
                 httpVersion: 'HTTP/1.1',
-                body: '<lockrequest/>',
+                body: '<lockinfo/>',
                 lock: {
                     timeout: 60,
                     lockscope: 'exclusive',
-                    owner: 'user-1',
-                    token: 'opaquetoken:abc'
-                }
+                    owner: 'test-user',
+                    token: 'opaquelocktoken:abc123'
+                },
+                ifHeaders: []
             },
             space: {
-                id: 10,
-                alias: 'spaceA',
-                url: '/spaces/spaceA/file.txt',
-                realPath: '/real/path/file.txt',
+                id: 1,
+                alias: 'test-space',
+                url: '/webdav/test/file.txt',
+                realPath: '/real/path/to/file.txt',
                 inSharesList: false,
                 dbFile: {
-                    path: 'file.txt'
+                    path: 'file.txt',
+                    spaceId: 1,
+                    inTrash: false
                 }
             },
             ...overrides
         });
-    beforeAll(async ()=>{
+    beforeEach(async ()=>{
+        // Initialize mocks
         filesManager = {
             sendFileFromSpace: jest.fn(),
-            mkFile: jest.fn().mockResolvedValue(undefined),
+            mkFile: jest.fn(),
             saveStream: jest.fn(),
-            delete: jest.fn().mockResolvedValue(undefined),
-            touch: jest.fn().mockResolvedValue(undefined),
-            mkDir: jest.fn().mockResolvedValue(undefined),
-            copyMove: jest.fn().mockResolvedValue(undefined)
+            delete: jest.fn(),
+            touch: jest.fn(),
+            mkDir: jest.fn(),
+            copyMove: jest.fn()
         };
         filesLockManager = {
             create: jest.fn(),
             isLockedWithToken: jest.fn(),
-            removeLock: jest.fn().mockResolvedValue(undefined),
+            removeLock: jest.fn(),
             browseLocks: jest.fn(),
             browseParentChildLocks: jest.fn(),
-            checkConflicts: jest.fn().mockResolvedValue(undefined),
+            checkConflicts: jest.fn(),
             getLocksByPath: jest.fn(),
             getLockByToken: jest.fn(),
-            refreshLockTimeout: jest.fn().mockResolvedValue(undefined)
+            refreshLockTimeout: jest.fn(),
+            genDAVToken: jest.fn().mockReturnValue('opaquelocktoken:new-token')
         };
         webDAVSpaces = {
             propfind: jest.fn(),
@@ -183,1436 +197,2290 @@ describe(_webdavmethodsservice.WebDAVMethods.name, ()=>{
             'fatal'
         ]);
         service = module.get(_webdavmethodsservice.WebDAVMethods);
-    });
-    beforeEach(()=>{
+        // Reset global mocks
         jest.clearAllMocks();
-        _files.isPathExists.mockReset().mockResolvedValue(true);
-        _files.dirName.mockReturnValue('/real/path');
+        _files.isPathExists.mockResolvedValue(true);
+        _files.dirName.mockReturnValue('/real/path/to');
         _permissions.haveSpaceEnvPermissions.mockReturnValue(true);
     });
     afterEach(()=>{
         jest.restoreAllMocks();
     });
-    it('should be defined', ()=>{
-        expect(service).toBeDefined();
+    describe('Service initialization', ()=>{
+        it('should be defined', ()=>{
+            expect(service).toBeDefined();
+            expect(service).toBeInstanceOf(_webdavmethodsservice.WebDAVMethods);
+        });
     });
     describe('headOrGet', ()=>{
-        it('streams the file when repository is FILES and not in shares list', async ()=>{
-            const req = baseReq();
-            const res = makeRes();
-            const streamable = {
-                stream: 'ok'
-            };
-            const send = {
-                checks: jest.fn().mockResolvedValue(undefined),
-                stream: jest.fn().mockResolvedValue(streamable)
-            };
-            filesManager.sendFileFromSpace.mockReturnValue(send);
-            const result = await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
-            expect(filesManager.sendFileFromSpace).toHaveBeenCalledWith(req.space);
-            expect(send.checks).toHaveBeenCalledTimes(1);
-            expect(send.stream).toHaveBeenCalledWith(req, res);
-            expect(result).toBe(streamable);
-        });
-        it('returns 403 when repository is not allowed', async ()=>{
-            const req = baseReq({
-                space: {
-                    ...baseReq().space,
-                    inSharesList: true
-                }
+        describe('Success cases', ()=>{
+            it('should stream file when repository is FILES and not in shares list', async ()=>{
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                const streamable = {
+                    stream: 'file-content'
+                };
+                const sendFile = {
+                    checks: jest.fn().mockResolvedValue(undefined),
+                    stream: jest.fn().mockResolvedValue(streamable)
+                };
+                filesManager.sendFileFromSpace.mockReturnValue(sendFile);
+                const result = await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(filesManager.sendFileFromSpace).toHaveBeenCalledWith(req.space);
+                expect(sendFile.checks).toHaveBeenCalledTimes(1);
+                expect(sendFile.stream).toHaveBeenCalledWith(req, res);
+                expect(result).toBe(streamable);
             });
-            const res = makeRes();
-            // repository not FILES or inSharesList true => forbidden
-            await service.headOrGet(req, res, 'OTHER');
-            expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
-            expect(res.body).toBe('Not allowed on this resource');
         });
-        it('handles error thrown by sendFile.checks via handleError', async ()=>{
-            const req = baseReq();
-            const res = makeRes();
-            const send = {
-                checks: jest.fn().mockRejectedValue(new Error('boom')),
-                stream: jest.fn()
-            };
-            filesManager.sendFileFromSpace.mockReturnValue(send);
-            const handleSpy = jest.spyOn(service, 'handleError').mockReturnValue('handled');
-            const result = await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
-            expect(handleSpy).toHaveBeenCalled();
-            expect(result).toBe('handled');
+        describe('Error cases', ()=>{
+            it('should return 403 when repository is not FILES', async ()=>{
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.headOrGet(req, res, 'OTHER_REPO');
+                expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
+                expect(res.body).toBe('Not allowed on this resource');
+            });
+            it('should return 403 when resource is in shares list', async ()=>{
+                const req = createBaseRequest({
+                    space: {
+                        ...createBaseRequest().space,
+                        inSharesList: true
+                    }
+                });
+                const res = createMockResponse();
+                await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
+                expect(res.body).toBe('Not allowed on this resource');
+            });
+            it('should handle errors from sendFile.checks', async ()=>{
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                const error = new Error('File check failed');
+                const sendFile = {
+                    checks: jest.fn().mockRejectedValue(error),
+                    stream: jest.fn()
+                };
+                filesManager.sendFileFromSpace.mockReturnValue(sendFile);
+                jest.spyOn(service, 'handleError').mockReturnValue('error-handled');
+                const result = await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(result).toBe('error-handled');
+            });
+            it('should handle errors from sendFile.stream', async ()=>{
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                const error = new Error('Stream failed');
+                const sendFile = {
+                    checks: jest.fn().mockResolvedValue(undefined),
+                    stream: jest.fn().mockRejectedValue(error)
+                };
+                filesManager.sendFileFromSpace.mockReturnValue(sendFile);
+                jest.spyOn(service, 'handleError').mockReturnValue('error-handled');
+                const result = await service.headOrGet(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(result).toBe('error-handled');
+            });
         });
     });
     describe('lock', ()=>{
-        it('when body is empty: returns 400 if resource does not exist (lock refresh)', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(false);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: undefined
-                }
+        describe('Lock refresh (without body)', ()=>{
+            it('should return 400 if resource does not exist for lock refresh', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined
+                    }
+                });
+                const res = createMockResponse();
+                await service.lock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toBe('Lock refresh must specify an existing resource');
+            });
+            it('should delegate to lockRefresh when resource exists and no body', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined
+                    }
+                });
+                const res = createMockResponse();
+                const lockRefreshSpy = jest.spyOn(service, 'lockRefresh').mockResolvedValue('refresh-ok');
+                const result = await service.lock(req, res);
+                expect(lockRefreshSpy).toHaveBeenCalledWith(req, res, req.space.dbFile.path);
+                expect(result).toBe('refresh-ok');
             });
-            const res = makeRes();
-            await service.lock(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
-            expect(res.body).toBe('Lock refresh must specify an existing resource');
         });
-        it('when body is empty: delegates to lockRefresh if resource exists', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: undefined
-                }
+        describe('Lock creation on existing resource', ()=>{
+            it('should create lock successfully and return 200', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                filesLockManager.create.mockImplementation(async (_user, _dbFile, _app, _depth, options, _timeout)=>{
+                    return [
+                        true,
+                        {
+                            owner: {
+                                fullName: 'LockOwner',
+                                email: 'lock-owner@sync-in.com'
+                            },
+                            dbFilePath: _dbFile?.path,
+                            options: {
+                                lockRoot: options.lockRoot,
+                                lockToken: options.lockToken,
+                                lockScope: options.lockScope,
+                                lockInfo: options.lockInfo
+                            }
+                        }
+                    ];
+                });
+                await service.lock(req, res);
+                expect(filesLockManager.create).toHaveBeenCalledTimes(1);
+                expect(res.statusCode).toBe(_common.HttpStatus.OK);
+                expect(res.contentType).toBe('application/xml; charset=utf-8');
+                expect(res.headers['lock-token']).toContain('opaquelocktoken:new-token');
+                expect(res.body).toBeDefined();
+                expect(typeof res.body).toBe('string');
             });
-            const res = makeRes();
-            const lockRefreshSpy = jest.spyOn(service, 'lockRefresh').mockResolvedValue('ok');
-            const result = await service.lock(req, res);
-            expect(lockRefreshSpy).toHaveBeenCalledWith(req, res, req.space.dbFile.path);
-            expect(result).toBe('ok');
         });
-        it('returns 403 when creating new lock on non-existing resource without permission', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValueOnce(false) // resource does not exist
-            ;
-            _permissions.haveSpaceEnvPermissions.mockReturnValue(false);
-            const req = baseReq();
-            const res = makeRes();
-            await service.lock(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
-            expect(res.body).toBe('You are not allowed to do this action');
-            expect(filesLockManager.create).not.toHaveBeenCalled();
-        });
-        it('returns 409 when parent does not exist for new lock', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValueOnce(false) // resource does not exist
-            .mockResolvedValueOnce(false) // parent does not exist
-            ;
-            _permissions.haveSpaceEnvPermissions.mockReturnValue(true);
-            _files.dirName.mockReturnValue('/real/path/parent-missing');
-            const req = baseReq();
-            const res = makeRes();
-            await service.lock(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.CONFLICT);
-            expect(res.body).toBe('Parent must exists');
-            expect(filesLockManager.create).not.toHaveBeenCalled();
-        });
-        it('creates lock on existing resource and returns 200 with lock-token header', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true); // resource exists
-            const req = baseReq();
-            const res = makeRes();
-            filesLockManager.create.mockImplementation(async (_user, _dbFile, _depth, davLock, _timeout)=>{
-                davLock.locktoken = 'opaquetoken:1';
-                return [
-                    true,
-                    {
-                        dbFilePath: _dbFile?.path,
-                        davLock: {
-                            lockroot: davLock.lockroot,
-                            locktoken: davLock.locktoken,
-                            lockscope: davLock.lockscope,
-                            owner: davLock.owner,
-                            depth: _depth,
-                            timeout: _timeout
+        describe('Lock creation on non-existent resource', ()=>{
+            it('should return 403 when user lacks ADD permission', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                _permissions.haveSpaceEnvPermissions.mockReturnValue(false);
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.lock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
+                expect(res.body).toBe('You are not allowed to do this action');
+                expect(filesLockManager.create).not.toHaveBeenCalled();
+            });
+            it('should return 409 when parent directory does not exist', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValueOnce(false) // resource
+                .mockResolvedValueOnce(false) // parent
+                ;
+                _permissions.haveSpaceEnvPermissions.mockReturnValue(true);
+                _files.dirName.mockReturnValue('/real/path/missing');
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.lock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.CONFLICT);
+                expect(res.body).toBe('Parent must exists');
+                expect(filesLockManager.create).not.toHaveBeenCalled();
+            });
+            it('should create empty file and lock, return 201', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValueOnce(false) // resource
+                .mockResolvedValueOnce(true); // parent exists
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                filesLockManager.create.mockImplementation(async (_user, _dbFile, _app, _depth, options)=>{
+                    return [
+                        true,
+                        {
+                            owner: {
+                                fullName: 'LockOwner',
+                                email: 'lock-owner@sync-in.com'
+                            },
+                            dbFilePath: _dbFile?.path,
+                            options: {
+                                lockRoot: options.lockRoot,
+                                lockToken: options.lockToken,
+                                lockScope: options.lockScope,
+                                lockInfo: options.lockInfo
+                            }
                         }
-                    }
-                ];
+                    ];
+                });
+                await service.lock(req, res);
+                expect(filesManager.mkFile).toHaveBeenCalledWith(req.user, req.space, false, false, false);
+                expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+                expect(res.headers['lock-token']).toContain('opaquelocktoken:new-token');
             });
-            await service.lock(req, res);
-            expect(filesLockManager.create).toHaveBeenCalledTimes(1);
-            expect(res.headers['lock-token']).toBe('<opaquetoken:1>');
-            expect(res.statusCode).toBe(_common.HttpStatus.OK);
-            expect(res.contentType).toBe('application/xml; charset=utf-8');
-            expect(res.body).toBeDefined();
         });
-        it('creates lock on unmapped URL (resource missing), creates empty file and returns 201', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValueOnce(false) // resource missing
-            .mockResolvedValueOnce(true); // parent exists
-            const req = baseReq();
-            const res = makeRes();
-            filesLockManager.create.mockImplementation(async (_user, _dbFile, _depth, davLock, _timeout)=>{
-                davLock.locktoken = 'opaquetoken:new';
-                return [
-                    true,
+        describe('Lock conflict', ()=>{
+            it('should return 423 when lock conflict occurs', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                filesLockManager.create.mockResolvedValue([
+                    false,
                     {
-                        dbFilePath: _dbFile?.path,
-                        davLock: {
-                            lockroot: davLock.lockroot,
-                            locktoken: davLock.locktoken,
-                            lockscope: davLock.lockscope,
-                            owner: davLock.owner,
-                            depth: _depth,
-                            timeout: _timeout
+                        owner: {
+                            fullName: 'LockOwner',
+                            email: 'lock-owner@sync-in.com'
+                        },
+                        dbFilePath: 'file.txt',
+                        options: {
+                            lockRoot: '/webdav/locked/resource'
                         }
                     }
-                ];
+                ]);
+                await service.lock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+                expect(res.contentType).toBe('application/xml; charset=utf-8');
             });
-            await service.lock(req, res);
-            expect(filesManager.mkFile).toHaveBeenCalledTimes(1);
-            expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
-            expect(res.headers['lock-token']).toBe('<opaquetoken:new>');
-        });
-        it('returns 423 when a lock conflict occurs', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq();
-            const res = makeRes();
-            filesLockManager.create.mockResolvedValue([
-                false,
-                {
-                    davLock: {
-                        lockroot: '/locked'
-                    },
-                    dbFilePath: 'file.txt'
-                }
-            ]);
-            await service.lock(req, res);
-            // DAV_ERROR_RES should have set 423 on the response
-            expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
         });
     });
     describe('unlock', ()=>{
-        it('returns 404 when resource does not exist', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(false);
-            const req = baseReq();
-            const res = makeRes();
-            await service.unlock(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
-            expect(res.body).toBe(req.dav.url);
-        });
-        it('returns 409 when lock token does not exist or does not match URL', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.isLockedWithToken.mockResolvedValue(null);
-            const req = baseReq();
-            const res = makeRes();
-            await service.unlock(req, res);
-            expect(filesLockManager.isLockedWithToken).toHaveBeenCalledWith(req.dav.lock.token, req.space.dbFile.path);
-            expect(res.statusCode).toBe(_common.HttpStatus.CONFLICT);
-        });
-        it('returns 403 when the lock owner is a different user', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.isLockedWithToken.mockResolvedValue({
-                owner: {
-                    id: 2
-                },
-                key: 'k1'
-            });
-            const req = baseReq();
-            const res = makeRes();
-            await service.unlock(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
-            expect(res.body).toBe('Token was created by another user');
-            expect(filesLockManager.removeLock).not.toHaveBeenCalled();
+        describe('Success cases', ()=>{
+            it('should unlock resource and return 204', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.isLockedWithToken.mockResolvedValue({
+                    owner: {
+                        id: 1,
+                        login: 'test-user'
+                    },
+                    key: 'lock-key-123'
+                });
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.unlock(req, res);
+                expect(filesLockManager.removeLock).toHaveBeenCalledWith('lock-key-123');
+                expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
+            });
         });
-        it('removes lock and returns 204 when owner matches', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.isLockedWithToken.mockResolvedValue({
-                owner: {
-                    id: 1
-                },
-                key: 'k2'
+        describe('Error cases', ()=>{
+            it('should return 404 when resource does not exist', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.unlock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
+                expect(res.body).toBe(req.dav.url);
+            });
+            it('should return 409 when lock token does not exist', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.isLockedWithToken.mockResolvedValue(null);
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.unlock(req, res);
+                expect(filesLockManager.isLockedWithToken).toHaveBeenCalledWith(req.dav.lock.token, req.space.dbFile.path);
+                expect(res.statusCode).toBe(_common.HttpStatus.CONFLICT);
+            });
+            it('should return 403 when lock owner is different user', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.isLockedWithToken.mockResolvedValue({
+                    owner: {
+                        id: 999,
+                        login: 'other-user'
+                    },
+                    key: 'lock-key-456'
+                });
+                const req = createBaseRequest();
+                const res = createMockResponse();
+                await service.unlock(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
+                expect(res.body).toBe('Token was created by another user');
+                expect(filesLockManager.removeLock).not.toHaveBeenCalled();
             });
-            const req = baseReq();
-            const res = makeRes();
-            await service.unlock(req, res);
-            expect(filesLockManager.removeLock).toHaveBeenCalledWith('k2');
-            expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
         });
     });
     describe('propfind', ()=>{
-        it('returns 404 when repository is FILES and path does not exist', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(false);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    propfindMode: 'prop'
-                }
-            });
-            const res = makeRes();
-            const result = await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
-            expect(result).toBe(res);
-            expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
-            expect(res.body).toBe(req.dav.url);
-        });
-        it('returns multistatus with only property names when PROPNAME mode', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    propfindMode: 'propname',
-                    httpVersion: 'HTTP/1.1'
-                }
-            });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'propfind').mockImplementation(async function*() {
-                yield {
-                    href: '/a',
-                    name: 'file.txt'
-                };
-            });
-            const result = await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
-            expect(result).toBe(res);
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(res.contentType).toContain('application/xml');
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('/a');
-        });
-        it('collects lock discovery based on depth', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req0 = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: {
-                        propfind: {
-                            prop: {
-                                [_webdav.STANDARD_PROPS[0]]: ''
+        describe('Base cases', ()=>{
+            it('should return 404 when resource does not exist in FILES repository', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'prop'
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(result).toBe(res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
+                expect(res.body).toBe(req.dav.url);
+            });
+            it('should return multistatus with property names in PROPNAME mode', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'propname'
+                    }
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/test/file.txt',
+                        name: 'file.txt'
+                    };
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.contentType).toContain('application/xml');
+                expect(typeof res.body).toBe('string');
+                expect(res.body).toContain('/webdav/test/file.txt');
+            });
+            it('should return multistatus with property values in PROP mode', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'prop',
+                        body: {
+                            propfind: {
+                                prop: {
+                                    [_webdav.STANDARD_PROPS[0]]: ''
+                                }
                             }
                         }
-                    },
-                    propfindMode: 'prop',
-                    httpVersion: 'HTTP/1.1',
-                    depth: '0'
-                }
+                    }
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/test/file.txt',
+                        name: 'file.txt',
+                        getlastmodified: 'Mon, 01 Jan 2024 00:00:00 GMT'
+                    };
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.contentType).toContain('application/xml');
+                expect(typeof res.body).toBe('string');
             });
-            const reqInf = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: {
-                        propfind: {
-                            prop: {
-                                [_webdav.STANDARD_PROPS[0]]: ''
+        });
+        describe('Lock discovery', ()=>{
+            it('should collect locks with depth 0', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'prop',
+                        depth: _webdav.DEPTH.RESOURCE,
+                        body: {
+                            propfind: {
+                                prop: {
+                                    [_webdav.LOCK_DISCOVERY_PROP]: ''
+                                }
                             }
                         }
-                    },
-                    propfindMode: 'prop',
-                    httpVersion: 'HTTP/1.1',
-                    depth: 'infinity'
-                }
-            });
-            const res0 = makeRes();
-            const resInf = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'propfind').mockImplementation(async function*() {
-                yield {
-                    href: '/a',
-                    name: 'file.txt',
-                    getlastmodified: 'x'
-                };
-            });
-            filesLockManager.browseLocks.mockResolvedValue({
-                'file.txt': {
-                    davLock: {
-                        lockroot: '/dav/url'
                     }
-                }
-            });
-            await service.propfind(req0, res0, _spaces.SPACE_REPOSITORY.FILES);
-            expect(filesLockManager.browseLocks).toHaveBeenCalledTimes(1);
-            filesLockManager.browseParentChildLocks.mockResolvedValue({
-                'file.txt': {
-                    davLock: {
-                        lockroot: '/dav/url'
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/test/file.txt',
+                        name: 'file.txt'
+                    };
+                });
+                filesLockManager.browseLocks.mockResolvedValue({
+                    'file.txt': {
+                        owner: {
+                            fullName: 'LockOwner',
+                            email: 'lock-owner@sync-in.com'
+                        },
+                        options: {
+                            lockRoot: '/webdav/test/file.txt'
+                        }
                     }
-                }
-            });
-            await service.propfind(reqInf, resInf, _spaces.SPACE_REPOSITORY.FILES);
-            expect(filesLockManager.browseParentChildLocks).toHaveBeenCalledTimes(1);
-        });
-        it('includes lockdiscovery when requested', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    propfindMode: 'prop',
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propfind: {
-                            prop: {
-                                lockdiscovery: ''
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(filesLockManager.browseLocks).toHaveBeenCalledWith(req.space.dbFile);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+            });
+            it('should collect parent and child locks with depth infinity', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'prop',
+                        depth: 'infinity',
+                        body: {
+                            propfind: {
+                                prop: {
+                                    [_webdav.LOCK_DISCOVERY_PROP]: ''
+                                }
                             }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'propfind').mockImplementation(async function*() {
-                yield {
-                    href: '/a',
-                    name: 'file.txt'
-                };
-            });
-            filesLockManager.browseLocks.mockResolvedValue({
-                'file.txt': {
-                    davLock: {
-                        lockroot: '/dav/url'
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/test/file.txt',
+                        name: 'file.txt'
+                    };
+                });
+                filesLockManager.browseParentChildLocks.mockResolvedValue({
+                    'file.txt': {
+                        owner: {
+                            fullName: 'LockOwner',
+                            email: 'lock-owner@sync-in.com'
+                        },
+                        options: {
+                            lockRoot: '/webdav/test/file.txt'
+                        }
                     }
-                }
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(filesLockManager.browseParentChildLocks).toHaveBeenCalledWith(req.space.dbFile);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+            });
+            it('should not collect locks for PROPNAME mode', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: _webdav.PROPSTAT.PROPNAME
+                    }
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/test',
+                        name: 'test'
+                    };
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(filesLockManager.browseLocks).not.toHaveBeenCalled();
+                expect(filesLockManager.browseParentChildLocks).not.toHaveBeenCalled();
+            });
+            it('should not collect locks for shares list', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    space: {
+                        ...createBaseRequest().space,
+                        inSharesList: true
+                    },
+                    dav: {
+                        ...createBaseRequest().dav,
+                        propfindMode: 'prop',
+                        body: {
+                            propfind: {
+                                prop: {
+                                    [_webdav.LOCK_DISCOVERY_PROP]: ''
+                                }
+                            }
+                        }
+                    }
+                });
+                const res = createMockResponse();
+                webDAVSpaces.propfind.mockImplementation(async function*() {
+                    yield {
+                        href: '/webdav/shares',
+                        name: 'shares'
+                    };
+                });
+                await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
+                expect(filesLockManager.browseLocks).not.toHaveBeenCalled();
             });
-            await service.propfind(req, res, _spaces.SPACE_REPOSITORY.FILES);
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('/dav/url');
         });
     });
     describe('put', ()=>{
-        it.each([
-            {
-                existed: true,
-                expected: _common.HttpStatus.NO_CONTENT,
-                checkEtag: true
-            },
-            {
-                existed: false,
-                expected: _common.HttpStatus.CREATED,
-                checkEtag: false
-            }
-        ])('returns correct status for PUT when existed=%s', async ({ existed, expected, checkEtag })=>{
-            filesManager.saveStream.mockResolvedValue(existed);
-            const req = baseReq({
-                method: 'PUT'
-            });
-            const res = makeRes();
-            const result = await service.put(req, res);
-            if (checkEtag) {
+        describe('Success cases', ()=>{
+            it('should return 204 when updating existing file', async ()=>{
+                filesManager.saveStream.mockResolvedValue(true); // file existed
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                const result = await service.put(req, res);
+                expect(filesManager.saveStream).toHaveBeenCalledWith(req.user, req.space, req, expect.objectContaining({
+                    dav: expect.any(Object)
+                }));
+                expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
                 expect(res.headers['etag']).toBeDefined();
                 expect(result).toBe(res);
-            }
-            expect(res.statusCode).toBe(expected);
+            });
+            it('should return 201 when creating new file', async ()=>{
+                filesManager.saveStream.mockResolvedValue(false); // file didn't exist
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                const result = await service.put(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+                expect(res.headers['etag']).toBeDefined();
+                expect(result).toBe(res);
+            });
+            it('should extract and pass lock tokens from if-headers', async ()=>{
+                filesManager.saveStream.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    method: 'PUT',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:xyz',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                jest.spyOn(_ifheader, 'extractAllTokens').mockReturnValue([
+                    'opaquelocktoken:xyz'
+                ]);
+                await service.put(req, res);
+                expect(filesManager.saveStream).toHaveBeenCalledWith(req.user, req.space, req, expect.objectContaining({
+                    dav: expect.objectContaining({
+                        lockTokens: [
+                            'opaquelocktoken:xyz'
+                        ]
+                    })
+                }));
+            });
         });
-        it('delegates errors to handleError', async ()=>{
-            const req = baseReq({
-                method: 'PUT'
-            });
-            const res = makeRes();
-            const err = new Error('save failed');
-            filesManager.saveStream.mockRejectedValue(err);
-            const spy = jest.spyOn(service, 'handleError').mockReturnValue('handled');
-            const result = await service.put(req, res);
-            expect(spy).toHaveBeenCalled();
-            expect(result).toBe('handled');
+        describe('Error handling', ()=>{
+            it('should handle lock conflict error', async ()=>{
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'file.txt',
+                    options: {
+                        lockRoot: '/webdav/locked'
+                    }
+                }, 'Lock conflict');
+                filesManager.saveStream.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                await service.put(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
+            it('should handle file error', async ()=>{
+                const fileError = new _fileerror.FileError(409, 'File conflict');
+                filesManager.saveStream.mockRejectedValue(fileError);
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                await service.put(req, res);
+                expect(res.statusCode).toBe(409);
+                expect(res.body).toBe('File conflict');
+            });
+            it('should throw HttpException for unexpected errors', async ()=>{
+                const unexpectedError = new Error('Unexpected error');
+                filesManager.saveStream.mockRejectedValue(unexpectedError);
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                await expect(service.put(req, res)).rejects.toThrow(_common.HttpException);
+            });
         });
     });
     describe('delete', ()=>{
-        it('returns 204 on success', async ()=>{
-            const req = baseReq({
-                method: 'DELETE'
-            });
-            const res = makeRes();
-            const result = await service.delete(req, res);
-            expect(result).toBe(res);
-            expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
+        describe('Success cases', ()=>{
+            it('should delete resource and return 204', async ()=>{
+                filesManager.delete.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'DELETE'
+                });
+                const res = createMockResponse();
+                const result = await service.delete(req, res);
+                expect(filesManager.delete).toHaveBeenCalledWith(req.user, req.space, expect.objectContaining({
+                    lockTokens: expect.any(Array)
+                }));
+                expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
+                expect(result).toBe(res);
+            });
+            it('should extract lock tokens from if-headers', async ()=>{
+                filesManager.delete.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'DELETE',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                jest.spyOn(_ifheader, 'extractAllTokens').mockReturnValue([
+                    'opaquelocktoken:abc'
+                ]);
+                await service.delete(req, res);
+                expect(filesManager.delete).toHaveBeenCalledWith(req.user, req.space, expect.objectContaining({
+                    lockTokens: [
+                        'opaquelocktoken:abc'
+                    ]
+                }));
+            });
         });
-        it('delegates errors to handleError', async ()=>{
-            const req = baseReq({
-                method: 'DELETE'
-            });
-            const res = makeRes();
-            const err = new Error('delete failed');
-            filesManager.delete.mockRejectedValue(err);
-            const spy = jest.spyOn(service, 'handleError').mockReturnValue('handled');
-            const result = await service.delete(req, res);
-            expect(spy).toHaveBeenCalled();
-            expect(result).toBe('handled');
+        describe('Error handling', ()=>{
+            it('should handle lock conflict', async ()=>{
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'file.txt',
+                    options: {
+                        lockRoot: '/webdav/locked'
+                    }
+                }, 'Lock conflict');
+                filesManager.delete.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'DELETE'
+                });
+                const res = createMockResponse();
+                await service.delete(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
+            it('should handle file errors', async ()=>{
+                const fileError = new _fileerror.FileError(404, 'File not found');
+                filesManager.delete.mockRejectedValue(fileError);
+                const req = createBaseRequest({
+                    method: 'DELETE'
+                });
+                const res = createMockResponse();
+                await service.delete(req, res);
+                expect(res.statusCode).toBe(404);
+                expect(res.body).toBe('File not found');
+            });
+            it('should throw HttpException for unexpected errors', async ()=>{
+                const unexpectedError = new Error('Database error');
+                filesManager.delete.mockRejectedValue(unexpectedError);
+                const req = createBaseRequest({
+                    method: 'DELETE'
+                });
+                const res = createMockResponse();
+                await expect(service.delete(req, res)).rejects.toThrow(_common.HttpException);
+            });
         });
     });
     describe('proppatch', ()=>{
-        it('returns 404 when target does not exist', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(false);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    url: '/x',
-                    body: {
-                        propertyupdate: {}
+        describe('Base cases', ()=>{
+            it('should return 404 when resource does not exist', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            lastmodified: '2024-01-01'
+                                        }
+                                    ]
+                                }
+                            }
+                        }
                     }
-                }
-            });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
-            expect(res.body).toBe('/x');
-        });
-        it('returns 400 for unknown action tag', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    body: {
-                        propertyupdate: {
-                            unknown: {}
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
+                expect(res.body).toBe(req.dav.url);
+            });
+            it('should return 400 for unknown action tag', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: {
+                            propertyupdate: {
+                                invalidaction: {}
+                            }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
-            expect(res.body).toContain('Unknown tag');
-        });
-        it('returns 400 when missing prop tag', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                foo: 'bar'
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toContain('Unknown tag');
+            });
+            it('should return 400 when missing prop tag', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    notprop: {}
+                                }
                             }
                         }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toContain('Unknown tag');
             });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
-            expect(res.body).toContain('Unknown tag');
         });
-        it('returns 207 with errors when unsupported props are provided', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: [
-                                    {
-                                        randomProp: 'x'
-                                    }
-                                ]
+        describe('SET action', ()=>{
+            it('should successfully modify lastmodified property', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                filesManager.touch.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            lastmodified: '2024-01-01'
+                                        }
+                                    ]
+                                }
                             }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(res.contentType).toContain('application/xml');
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('randomProp');
-            expect(res.body).toContain('403');
-        });
-        it('applies modified props and still returns 207; failed dependency if one fails', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            filesManager.touch.mockResolvedValueOnce(undefined);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: [
-                                    {
-                                        lastmodified: '2024-01-01'
-                                    },
-                                    {
-                                        ['Win32CreationTime']: 'keep'
-                                    }
-                                ]
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesManager.touch).toHaveBeenCalled();
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.contentType).toContain('application/xml');
+                expect(typeof res.body).toBe('string');
+                expect(res.body).toContain('lastmodified');
+                expect(res.body).toContain('200');
+            });
+            it('should return 207 with 403 for unsupported properties', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            unsupportedProp: 'value'
+                                        }
+                                    ]
+                                }
                             }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(filesManager.touch).toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('lastmodified');
-            expect(res.body).toContain('200');
-        });
-        it('delegates lock conflict to handleError when checkConflicts throws', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: [
-                                    {
-                                        lastmodified: 'x'
-                                    }
-                                ]
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('unsupportedProp');
+                expect(res.body).toContain('403');
+            });
+            it('should handle Win32 properties correctly', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            Win32CreationTime: '2024-01-01'
+                                        }
+                                    ]
+                                }
                             }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            const err = new Error('conflict');
-            filesLockManager.checkConflicts.mockRejectedValue(err);
-            const spy = jest.spyOn(service, 'handleError').mockReturnValue('handled');
-            const result = await service.proppatch(req, res);
-            expect(spy).toHaveBeenCalled();
-            expect(result).toBe('handled');
-        });
-        it('normalizes array of propertyupdate items containing {prop: ...}', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            filesManager.touch.mockResolvedValueOnce(undefined);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: [
-                                {
-                                    prop: {
-                                        lastmodified: '2024-03-01'
-                                    }
-                                },
-                                {
-                                    prop: {
-                                        ['Win32CreationTime']: 'ignore'
-                                    }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesManager.touch).not.toHaveBeenCalled();
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('Win32CreationTime');
+                expect(res.body).toContain('200');
+            });
+            it('should return 424 failed dependency when touch fails', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                filesManager.touch.mockRejectedValue(new Error('Touch failed'));
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            lastmodified: '2024-01-01'
+                                        }
+                                    ]
                                 }
-                            ]
+                            }
                         }
                     }
-                }
-            });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(filesManager.touch).toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(res.contentType).toContain('application/xml');
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('lastmodified');
-            expect(res.body).toContain('200');
-        });
-        it('wraps single prop object into an array for processing', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: {
-                                    lastmodified: '2024-03-02'
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('424');
+            });
+            it('should mark supported props as 424 when unsupported prop fails', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            unsupportedProp: 'fail'
+                                        },
+                                        {
+                                            Win32CreationTime: 'ok'
+                                        }
+                                    ]
                                 }
                             }
                         }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('unsupportedProp');
+                expect(res.body).toContain('403');
+                expect(res.body).toContain('Win32CreationTime');
+                expect(res.body).toContain('424');
             });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(filesManager.touch).toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('lastmodified');
-            expect(res.body).toContain('200');
         });
-        it('handles REMOVE action on supported property and returns 207', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            remove: {
-                                prop: [
-                                    {
-                                        ['Win32CreationTime']: ''
-                                    }
-                                ]
+        describe('REMOVE action', ()=>{
+            it('should handle REMOVE action on supported property', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                remove: {
+                                    prop: [
+                                        {
+                                            Win32CreationTime: ''
+                                        }
+                                    ]
+                                }
                             }
                         }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesManager.touch).not.toHaveBeenCalled();
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('Win32CreationTime');
+                expect(res.body).toContain('200');
             });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(filesManager.touch).not.toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(res.contentType).toContain('application/xml');
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('Win32CreationTime');
-            expect(res.body).toContain('200');
         });
-        it('returns 207 with 424 Failed Dependency when touching lastmodified fails', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            filesManager.touch.mockRejectedValueOnce(new Error('touch failed'));
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: [
+        describe('Data normalization', ()=>{
+            it('should normalize array of propertyupdate items', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                filesManager.touch.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: [
                                     {
-                                        lastmodified: '2024-01-01'
+                                        prop: {
+                                            lastmodified: '2024-01-01'
+                                        }
                                     },
                                     {
-                                        ['Win32CreationTime']: 'ok'
+                                        prop: {
+                                            Win32CreationTime: 'ok'
+                                        }
                                     }
                                 ]
                             }
                         }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesManager.touch).toHaveBeenCalled();
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
+                expect(res.body).toContain('lastmodified');
+            });
+            it('should wrap single prop object into array', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                filesManager.touch.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        httpVersion: 'HTTP/1.1',
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: {
+                                        lastmodified: '2024-01-01'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesManager.touch).toHaveBeenCalled();
+                expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
             });
-            const res = makeRes();
-            await service.proppatch(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(typeof res.body).toBe('string');
-            expect(res.body).toContain('424');
-            expect(res.body).toContain('lastmodified');
         });
-        it('returns 207 with 403 for unsupported prop and 424 for supported prop as failed dependency', async ()=>{
-            // Préparation : la ressource existe et pas de conflit de lock
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.checkConflicts.mockResolvedValue(undefined);
-            // On envoie à la fois une prop non supportée ('randomProp') et une prop supportée ('Win32CreationTime')
-            const req = baseReq({
-                method: 'PROPPATCH',
-                dav: {
-                    ...baseReq().dav,
-                    httpVersion: 'HTTP/1.1',
-                    body: {
-                        propertyupdate: {
-                            set: {
-                                prop: [
-                                    {
-                                        randomProp: 'x'
-                                    },
-                                    {
-                                        Win32CreationTime: 'keep'
-                                    }
-                                ]
+        describe('Lock handling', ()=>{
+            it('should check lock conflicts before applying changes', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                filesLockManager.checkConflicts.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            Win32CreationTime: 'ok'
+                                        }
+                                    ]
+                                }
                             }
                         }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(filesLockManager.checkConflicts).toHaveBeenCalledWith(req.space.dbFile, req.dav.depth, expect.objectContaining({
+                    userId: req.user.id,
+                    lockTokens: expect.any(Array)
+                }));
+            });
+            it('should handle lock conflict error', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'file.txt',
+                    options: {
+                        lockRoot: '/webdav/locked'
+                    }
+                }, 'Lock conflict');
+                filesLockManager.checkConflicts.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'PROPPATCH',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: {
+                            propertyupdate: {
+                                set: {
+                                    prop: [
+                                        {
+                                            lastmodified: '2024-01-01'
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                });
+                const res = createMockResponse();
+                await service.proppatch(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
             });
-            const res = makeRes();
-            // Exécution
-            await service.proppatch(req, res);
-            // Assertions : multistatus, xml, et contenu
-            expect(res.statusCode).toBe(_common.HttpStatus.MULTI_STATUS);
-            expect(res.contentType).toContain('application/xml');
-            const xml = res.body;
-            // On doit trouver le nom de la prop non supportée avec status 403
-            expect(xml).toContain('randomProp');
-            expect(xml).toContain('403');
-            // On doit trouver le nom de la prop supportée avec status 424 (failed dependency)
-            expect(xml).toContain('Win32CreationTime');
-            expect(xml).toContain('424');
         });
     });
     describe('mkcol', ()=>{
-        it('returns 201 when directory created', async ()=>{
-            const req = baseReq({
-                method: 'MKCOL'
-            });
-            const res = makeRes();
-            await service.mkcol(req, res);
-            expect(filesManager.mkDir).toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+        describe('Success cases', ()=>{
+            it('should create directory and return 201', async ()=>{
+                filesManager.mkDir.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'MKCOL'
+                });
+                const res = createMockResponse();
+                await service.mkcol(req, res);
+                expect(filesManager.mkDir).toHaveBeenCalledWith(req.user, req.space, false, expect.objectContaining({
+                    depth: req.dav.depth,
+                    lockTokens: expect.any(Array)
+                }));
+                expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+            });
         });
-        it('delegates errors to handleError', async ()=>{
-            const req = baseReq({
-                method: 'MKCOL'
-            });
-            const res = makeRes();
-            filesManager.mkDir.mockRejectedValue(new Error('mkdir failed'));
-            const spy = jest.spyOn(service, 'handleError').mockReturnValue('handled');
-            const result = await service.mkcol(req, res);
-            expect(spy).toHaveBeenCalled();
-            expect(result).toBe('handled');
+        describe('Error handling', ()=>{
+            it('should handle lock conflict', async ()=>{
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'dir',
+                    options: {
+                        lockRoot: '/webdav/locked'
+                    }
+                }, 'Lock conflict');
+                filesManager.mkDir.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'MKCOL'
+                });
+                const res = createMockResponse();
+                await service.mkcol(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
+            it('should handle file errors', async ()=>{
+                const fileError = new _fileerror.FileError(409, 'Directory already exists');
+                filesManager.mkDir.mockRejectedValue(fileError);
+                const req = createBaseRequest({
+                    method: 'MKCOL'
+                });
+                const res = createMockResponse();
+                await service.mkcol(req, res);
+                expect(res.statusCode).toBe(409);
+                expect(res.body).toBe('Directory already exists');
+            });
+            it('should throw HttpException for unexpected errors', async ()=>{
+                const unexpectedError = new Error('Filesystem error');
+                filesManager.mkDir.mockRejectedValue(unexpectedError);
+                const req = createBaseRequest({
+                    method: 'MKCOL'
+                });
+                const res = createMockResponse();
+                await expect(service.mkcol(req, res)).rejects.toThrow(_common.HttpException);
+            });
         });
     });
     describe('copyMove', ()=>{
-        it('returns 404 when destination space not found', async ()=>{
-            const req = baseReq({
-                method: 'MOVE',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/unknown',
-                        isMove: false,
-                        overwrite: false
+        describe('Base cases', ()=>{
+            it('should return 404 when destination space not found', async ()=>{
+                webDAVSpaces.spaceEnv.mockResolvedValue(null);
+                const req = createBaseRequest({
+                    method: 'MOVE',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/unknown',
+                            isMove: true,
+                            overwrite: false
+                        }
                     }
-                }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
+                expect(res.body).toBe('/webdav/unknown');
             });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue(null);
-            await service.copyMove(req, res);
-            expect(res.statusCode).toBe(_common.HttpStatus.NOT_FOUND);
-            expect(res.body).toBe('/unknown');
         });
-        it('aborts when evaluateIfHeaders fails', async ()=>{
-            const req = baseReq({
-                method: 'COPY',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: false,
-                        overwrite: true
-                    },
-                    ifHeaders: [
-                        {
-                            path: '/dst',
-                            token: {
-                                value: 'bad',
-                                mustMatch: true
-                            }
+        describe('COPY operation', ()=>{
+            it('should copy file and return 201 when destination does not exist', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/copy.txt',
+                    realPath: '/real/path/to/copy.txt',
+                    dbFile: {
+                        path: 'copy.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                _files.isPathExists.mockResolvedValue(false);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                filesManager.copyMove.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/copy.txt',
+                            isMove: false,
+                            overwrite: false
                         }
-                    ]
-                }
-            });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue({
-                ...req.space,
-                url: '/dst',
-                realPath: '/real/dst',
-                dbFile: {
-                    path: 'dst'
-                }
-            });
-            const spy = jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(false);
-            const result = await service.copyMove(req, res);
-            expect(spy).toHaveBeenCalled();
-            expect(result).toBeUndefined();
-        });
-        it('aborts with 412 when destination If-Header haveLock mismatches', async ()=>{
-            const handler = service['webDAVHandler'];
-            const dstSpace = {
-                ...baseReq().space,
-                url: '/dst',
-                realPath: '/real/dst',
-                dbFile: {
-                    path: 'dst'
-                }
-            };
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue(dstSpace);
-            _files.isPathExists.mockResolvedValue(true);
-            filesLockManager.getLocksByPath.mockResolvedValue([
-                {}
-            ]); // there is a lock, but mustMatch=false -> mismatch
-            const req = baseReq({
-                method: 'COPY',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: false,
-                        overwrite: true
-                    },
-                    ifHeaders: [
-                        {
-                            path: '/dst',
-                            haveLock: {
-                                mustMatch: false
-                            }
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(filesManager.copyMove).toHaveBeenCalledWith(req.user, req.space, dstSpace, false, false, false, expect.objectContaining({
+                    depth: req.dav.depth,
+                    lockTokens: expect.any(Array)
+                }));
+                expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+            });
+            it('should copy file and return 204 when destination exists', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/existing.txt',
+                    realPath: '/real/path/to/existing.txt',
+                    dbFile: {
+                        path: 'existing.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                _files.isPathExists.mockResolvedValue(true);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                filesManager.copyMove.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/existing.txt',
+                            isMove: false,
+                            overwrite: true
                         }
-                    ]
-                }
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
             });
-            const res = makeRes();
-            const result = await service.copyMove(req, res);
-            expect(result).toBeUndefined();
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
-            expect(res.body).toBe('If header condition failed');
         });
-        it('returns 204 when destination existed; 201 when not', async ()=>{
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue({
-                ...baseReq().space,
-                url: '/dst',
-                realPath: '/real/dst',
-                dbFile: {
-                    path: 'dst'
-                }
-            });
-            jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
-            _files.isPathExists.mockResolvedValueOnce(true);
-            const req1 = baseReq({
-                method: 'MOVE',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: true,
-                        overwrite: true
+        describe('MOVE operation', ()=>{
+            it('should move file and return 201 when destination does not exist', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/moved.txt',
+                    realPath: '/real/path/to/moved.txt',
+                    dbFile: {
+                        path: 'moved.txt',
+                        spaceId: 1,
+                        inTrash: false
                     }
-                }
-            });
-            const res1 = makeRes();
-            await service.copyMove(req1, res1);
-            expect(res1.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
-            _files.isPathExists.mockResolvedValueOnce(false);
-            const req2 = baseReq({
-                method: 'COPY',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: false,
-                        overwrite: false
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                _files.isPathExists.mockResolvedValue(false);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                filesManager.copyMove.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'MOVE',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/moved.txt',
+                            isMove: true,
+                            overwrite: false
+                        }
                     }
-                }
-            });
-            const res2 = makeRes();
-            await service.copyMove(req2, res2);
-            expect(res2.statusCode).toBe(_common.HttpStatus.CREATED);
-        });
-        it('delegates errors to handleError', async ()=>{
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue({
-                ...baseReq().space,
-                url: '/dst',
-                realPath: '/real/dst',
-                dbFile: {
-                    path: 'dst'
-                }
-            });
-            jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
-            // Chain 1) LockConflict without lockroot (fallback to dbFilePath) then 2) unexpected error
-            const { LockConflict } = jest.requireActual('../../files/models/file-lock-error');
-            filesManager.copyMove.mockRejectedValueOnce(new LockConflict({
-                dbFilePath: 'dst'
-            })).mockRejectedValueOnce(new Error('copy failed'));
-            const req = baseReq({
-                method: 'COPY',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: false,
-                        overwrite: true
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(filesManager.copyMove).toHaveBeenCalledWith(req.user, req.space, dstSpace, true, false, false, expect.any(Object));
+                expect(res.statusCode).toBe(_common.HttpStatus.CREATED);
+            });
+            it('should move file and return 204 when destination exists', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/existing.txt',
+                    realPath: '/real/path/to/existing.txt',
+                    dbFile: {
+                        path: 'existing.txt',
+                        spaceId: 1,
+                        inTrash: false
                     }
-                }
-            });
-            // 1) LockConflict => DAV_ERROR_RES(423) using e.lock.dbFilePath
-            const res1 = makeRes();
-            const logSpy = jest.spyOn(service['logger'], 'error').mockImplementation(()=>undefined);
-            const result1 = await service.copyMove(req, res1);
-            expect(result1).toBe(res1);
-            expect(res1.statusCode).toBe(_common.HttpStatus.LOCKED);
-            // 2) Unexpected error => HttpException 500 and log contains " -> /dst"
-            const res2 = makeRes();
-            try {
-                await service.copyMove(req, res2);
-                expect(true).toBe(false); // should not reach
-            } catch (e) {
-                expect(e).toBeInstanceOf(_common.HttpException);
-                expect(e.getStatus()).toBe(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-            }
-            // Verify the log message includes an arrow to the destination (toUrl)
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(' -> /dst'));
-        });
-        it('returns early when evaluateIfHeaders returns false (explicit spy)', async ()=>{
-            const req = baseReq({
-                method: 'COPY',
-                dav: {
-                    ...baseReq().dav,
-                    copyMove: {
-                        destination: '/dst',
-                        isMove: false,
-                        overwrite: true
-                    },
-                    ifHeaders: [
-                        {
-                            path: '/dst'
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                _files.isPathExists.mockResolvedValue(true);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                filesManager.copyMove.mockResolvedValue(undefined);
+                const req = createBaseRequest({
+                    method: 'MOVE',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/existing.txt',
+                            isMove: true,
+                            overwrite: true
                         }
-                    ]
-                }
-            });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            // Ensure destination space resolves so we reach the evaluateIfHeaders call
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue({
-                ...req.space,
-                url: '/dst',
-                realPath: '/real/dst',
-                dbFile: {
-                    path: 'dst'
-                }
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.NO_CONTENT);
             });
-            _files.isPathExists.mockResolvedValue(true);
-            // Decorator is no-op (mocked), so copyMove calls evaluateIfHeaders once for destination: force it to return false
-            const spy = jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(false);
-            const result = await service.copyMove(req, res);
-            expect(spy).toHaveBeenCalledTimes(1);
-            expect(result).toBeUndefined();
-            expect(filesManager.copyMove).not.toHaveBeenCalled();
         });
-    });
-    describe('evaluateIfHeaders', ()=>{
-        it('returns true when no headers', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: undefined
-                }
+        describe('If-Headers on destination', ()=>{
+            it('should return early when evaluateIfHeaders fails for destination', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(false);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
+                        },
+                        ifHeaders: [
+                            {
+                                path: '/webdav/test/dest.txt',
+                                etag: {
+                                    value: 'W/"wrong"',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.copyMove(req, res);
+                expect(result).toBeUndefined();
+                expect(filesManager.copyMove).not.toHaveBeenCalled();
+            });
+            it('should return 412 when destination If-Header haveLock mismatches', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                _files.isPathExists.mockResolvedValue(true);
+                _paths.dbFileFromSpace.mockReturnValue(dstSpace.dbFile);
+                filesLockManager.getLocksByPath.mockResolvedValue([
+                    {
+                        key: 'lock1'
+                    }
+                ]);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
+                        },
+                        ifHeaders: [
+                            {
+                                path: '/webdav/test/dest.txt',
+                                haveLock: {
+                                    mustMatch: false
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.copyMove(req, res);
+                expect(result).toBeUndefined();
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
             });
-            const res = makeRes();
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(true);
         });
-        const negativeIfHeaderCases = [
-            {
-                name: 'haveLock mismatch',
-                dav: {
-                    ifHeaders: [
-                        {
-                            haveLock: {
-                                mustMatch: true
-                            }
+        describe('Error handling', ()=>{
+            it('should handle lock conflict error', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'dest.txt',
+                    options: {
+                        lockRoot: '/webdav/locked'
+                    }
+                }, 'Lock conflict');
+                filesManager.copyMove.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
                         }
-                    ]
-                },
-                setup: async ()=>{
-                    // No lock present => match=false, mustMatch=true => mismatch
-                    ;
-                    _paths.dbFileFromSpace.mockReturnValue({
-                        path: 'file.txt',
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
+            it('should handle lock conflict without lockRoot (fallback to dbFilePath)', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
                         spaceId: 1,
                         inTrash: false
-                    });
-                    filesLockManager.getLocksByPath.mockResolvedValue([]);
-                }
-            },
-            {
-                name: 'haveLock mismatch when locks exist but mustMatch=false',
-                dav: {
-                    ifHeaders: [
-                        {
-                            haveLock: {
-                                mustMatch: false
-                            }
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'dest.txt'
+                }, 'Lock conflict');
+                filesManager.copyMove.mockRejectedValue(lockError);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
                         }
-                    ]
-                },
-                setup: async ()=>{
-                    // Lock present => match=true, mustMatch=false => mismatch
-                    ;
-                    _paths.dbFileFromSpace.mockReturnValue({
-                        path: 'dst',
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
+            it('should handle file errors', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
                         spaceId: 1,
                         inTrash: false
-                    });
-                    filesLockManager.getLocksByPath.mockResolvedValue([
-                        {}
-                    ]);
-                }
-            },
-            {
-                name: 'token not found',
-                dav: {
-                    ifHeaders: [
-                        {
-                            token: {
-                                value: 'missing',
-                                mustMatch: true
-                            }
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                const fileError = new _fileerror.FileError(409, 'File conflict');
+                filesManager.copyMove.mockRejectedValue(fileError);
+                const req = createBaseRequest({
+                    method: 'MOVE',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: true,
+                            overwrite: false
                         }
-                    ]
-                },
-                setup: async ()=>{
-                    filesLockManager.getLockByToken.mockResolvedValue(null);
-                }
-            },
-            {
-                name: 'etag mismatch',
-                dav: {
-                    ifHeaders: [
-                        {
-                            etag: {
-                                value: 'W/"bad"',
-                                mustMatch: true
-                            }
+                    }
+                });
+                const res = createMockResponse();
+                await service.copyMove(req, res);
+                expect(res.statusCode).toBe(409);
+                expect(res.body).toBe('File conflict');
+            });
+            it('should throw HttpException for unexpected errors', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                const unexpectedError = new Error('Unexpected filesystem error');
+                filesManager.copyMove.mockRejectedValue(unexpectedError);
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
                         }
-                    ]
-                },
-                setup: async ()=>{
-                    ;
-                    _files.isPathExists.mockResolvedValue(true);
-                }
-            }
-        ];
-        it.each(negativeIfHeaderCases)('fails with 412 on %s', async ({ dav, setup })=>{
-            await setup();
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ...dav
+                    }
+                });
+                const res = createMockResponse();
+                await expect(service.copyMove(req, res)).rejects.toThrow(_common.HttpException);
+            });
+            it('should include destination URL in error log', async ()=>{
+                const dstSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/test/dest.txt',
+                    realPath: '/real/path/to/dest.txt',
+                    dbFile: {
+                        path: 'dest.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(dstSpace);
+                jest.spyOn(service, 'evaluateIfHeaders').mockResolvedValue(true);
+                const logSpy = jest.spyOn(service['logger'], 'error').mockImplementation(()=>undefined);
+                filesManager.copyMove.mockRejectedValue(new Error('Copy failed'));
+                const req = createBaseRequest({
+                    method: 'COPY',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        copyMove: {
+                            destination: '/webdav/test/dest.txt',
+                            isMove: false,
+                            overwrite: true
+                        }
+                    }
+                });
+                const res = createMockResponse();
+                try {
+                    await service.copyMove(req, res);
+                } catch  {
+                // Expected to throw
                 }
+                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(' -> /webdav/test/dest.txt'));
             });
-            const res = makeRes();
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(false);
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
         });
-        it('returns true when one condition matches', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(true);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            etag: {
-                                value: 'W/"bad"',
-                                mustMatch: true
+    });
+    describe('evaluateIfHeaders', ()=>{
+        describe('Base cases', ()=>{
+            it('should return true when no if-headers present', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: undefined
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+                expect(res.statusCode).toBeUndefined();
+            });
+            it('should return true when at least one condition matches', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"wrong-etag"',
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                etag: {
+                                    value: 'W/"etag-123"',
+                                    mustMatch: true
+                                }
                             }
-                        },
-                        {
-                            etag: {
-                                value: 'W/"etag"',
-                                mustMatch: true
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+                expect(res.statusCode).toBeUndefined();
+            });
+            it('should return false when path cannot be resolved', async ()=>{
+                webDAVSpaces.spaceEnv.mockResolvedValue(null);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                path: '/webdav/unknown/file.txt'
                             }
-                        } // this should pass
-                    ]
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBeUndefined();
             });
-            const res = makeRes();
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(true);
-            expect(res.statusCode).toBeUndefined();
         });
-        it('fails with 412 on token url mismatch', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            path: '/dav/other',
-                            token: {
-                                value: 'opaquetoken:xyz',
-                                mustMatch: true
+        describe('haveLock condition', ()=>{
+            it('should return true when haveLock matches (lock exists, mustMatch=true)', async ()=>{
+                ;
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockResolvedValue([
+                    {
+                        key: 'lock1'
+                    }
+                ]);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
-            });
-            const res = makeRes();
-            // Space for the explicit path
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue({
-                ...req.space,
-                url: '/dav/other',
-                realPath: '/real/other',
-                dbFile: {
-                    path: 'other'
-                }
-            });
-            filesLockManager.getLockByToken.mockResolvedValue({
-                davLock: {
-                    lockroot: '/dav/url'
-                }
-            }); // not a parent of /dav/other
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(false);
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
-        });
-        it('fails with 412 and logs error when haveLock lookup throws', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            path: '/dav/url',
-                            haveLock: {
-                                mustMatch: true
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return true when haveLock matches (no lock, mustMatch=false)', async ()=>{
+                ;
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockResolvedValue([]);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: false
+                                }
                             }
-                        }
-                    ]
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return false with 412 when haveLock mismatches (lock exists, mustMatch=false)', async ()=>{
+                ;
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockResolvedValue([
+                    {
+                        key: 'lock1'
+                    }
+                ]);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: false
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should return false with 412 when haveLock mismatches (no lock, mustMatch=true)', async ()=>{
+                ;
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockResolvedValue([]);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should return false with 412 when haveLock lookup throws error', async ()=>{
+                ;
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockRejectedValue(new Error('Database error'));
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+                expect(res.body).toBe('If header condition failed');
             });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue(req.space);
-            filesLockManager.getLocksByPath.mockRejectedValue(new Error('boom'));
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(false);
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
-            expect(res.body).toBe('If header condition failed');
         });
-        it('returns true when token exists and path matches lockroot', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            path: '/dav/url',
-                            token: {
-                                value: 'opaquetoken:good',
-                                mustMatch: true
+        describe('token condition', ()=>{
+            it('should return true when token exists and path matches lockroot', async ()=>{
+                filesLockManager.getLockByToken.mockResolvedValue({
+                    options: {
+                        lockRoot: '/webdav/test/file.txt'
+                    }
+                });
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
-            });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue(req.space);
-            filesLockManager.getLockByToken.mockResolvedValue({
-                davLock: {
-                    lockroot: '/dav/url'
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return true when token exists and path is child of lockroot', async ()=>{
+                filesLockManager.getLockByToken.mockResolvedValue({
+                    options: {
+                        lockRoot: '/webdav/test'
+                    }
+                });
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        url: '/webdav/test/subfolder/file.txt',
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return false with 412 when token not found', async ()=>{
+                filesLockManager.getLockByToken.mockResolvedValue(null);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:missing',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should return false with 412 when token exists but path does not match lockroot', async ()=>{
+                filesLockManager.getLockByToken.mockResolvedValue({
+                    options: {
+                        lockRoot: '/webdav/other/file.txt'
+                    }
+                });
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        url: '/webdav/test/file.txt',
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should evaluate token condition with explicit path in if-header', async ()=>{
+                const explicitSpace = {
+                    ...createBaseRequest().space,
+                    url: '/webdav/explicit/path.txt',
+                    realPath: '/real/path/to/explicit.txt',
+                    dbFile: {
+                        path: 'explicit/path.txt',
+                        spaceId: 1,
+                        inTrash: false
+                    }
+                };
+                webDAVSpaces.spaceEnv.mockResolvedValue(explicitSpace);
+                filesLockManager.getLockByToken.mockResolvedValue({
+                    options: {
+                        lockRoot: '/webdav/explicit'
+                    }
+                });
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                path: '/webdav/explicit/path.txt',
+                                token: {
+                                    value: 'opaquelocktoken:xyz',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(webDAVSpaces.spaceEnv).toHaveBeenCalledWith(req.user, '/webdav/explicit/path.txt');
+                expect(result).toBe(true);
             });
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(true);
-            expect(res.statusCode).toBeUndefined();
         });
-        it('returns false without setting status when If-Header path cannot be resolved', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            path: '/dav/missing'
-                        }
-                    ]
-                }
+        describe('etag condition', ()=>{
+            it('should return true when etag matches', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _files.genEtag.mockReturnValue('W/"etag-123"');
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"etag-123"',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return true when etag does not match and mustMatch=false', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _files.genEtag.mockReturnValue('W/"etag-123"');
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"different"',
+                                    mustMatch: false
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return false with 412 when etag mismatches', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _files.genEtag.mockReturnValue('W/"etag-123"');
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"wrong-etag"',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should return false with 412 when resource does not exist (null etag)', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(false);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"etag-123"',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should cache etag for multiple conditions on same path', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _files.genEtag.mockReturnValue('W/"etag-123"');
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"wrong1"',
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                etag: {
+                                    value: 'W/"etag-123"',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+                expect(_files.genEtag).toHaveBeenCalledTimes(1); // Cached
             });
-            const res = makeRes();
-            const handler = service['webDAVHandler'];
-            jest.spyOn(handler, 'spaceEnv').mockResolvedValue(null);
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(false);
-            expect(res.statusCode).toBeUndefined();
-            expect(res.body).toBeUndefined();
         });
-        it('fails with 412 on etag when resource does not exist (null etag)', async ()=>{
-            ;
-            _files.isPathExists.mockResolvedValue(false);
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ifHeaders: [
-                        {
-                            etag: {
-                                value: 'W/"etag"',
-                                mustMatch: true
+        describe('Multiple conditions', ()=>{
+            it('should evaluate multiple conditions and return true if any matches', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _paths.dbFileFromSpace.mockReturnValue({
+                    path: 'file.txt',
+                    spaceId: 1
+                });
+                filesLockManager.getLocksByPath.mockResolvedValue([]);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                haveLock: {
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                haveLock: {
+                                    mustMatch: false
+                                }
+                            } // Will succeed (no lock)
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(true);
+            });
+            it('should return false with 412 when all conditions fail', async ()=>{
+                ;
+                _files.isPathExists.mockResolvedValue(true);
+                _files.genEtag.mockReturnValue('W/"etag-123"');
+                filesLockManager.getLockByToken.mockResolvedValue(null);
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        ifHeaders: [
+                            {
+                                etag: {
+                                    value: 'W/"wrong1"',
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                etag: {
+                                    value: 'W/"wrong2"',
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:missing',
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const result = await service.evaluateIfHeaders(req, res);
+                expect(result).toBe(false);
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+                expect(res.body).toBe('If header condition failed');
             });
-            const res = makeRes();
-            const ok = await service.evaluateIfHeaders(req, res);
-            expect(ok).toBe(false);
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
         });
     });
-    describe('lockRefresh', ()=>{
-        const refresh400Cases = [
-            {
-                name: 'more than one or zero tokens in If header',
-                dav: {
-                    body: undefined,
-                    ifHeaders: []
-                },
-                expectMsg: 'Expected a lock token'
-            },
-            {
-                name: 'token extraction fails',
-                dav: {
-                    body: undefined,
-                    ifHeaders: [
-                        {
-                            notAToken: true
-                        }
-                    ]
-                },
-                expectMsg: 'Unable to extract token'
-            }
-        ];
-        it.each(refresh400Cases)('returns 400 when %s', async ({ dav, expectMsg })=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    ...dav
-                }
-            });
-            const res = makeRes();
-            await service.lockRefresh(req, res, req.space.dbFile.path);
-            expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
-            expect(res.body).toContain(expectMsg);
-        });
-        it('returns 412 when token not found or not matching URL', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: undefined,
-                    ifHeaders: [
-                        {
-                            token: {
-                                value: 'opaquetoken:missing',
-                                mustMatch: true
+    describe('lockRefresh (private method)', ()=>{
+        describe('Parameter validation', ()=>{
+            it('should return 400 when no if-headers present', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        ifHeaders: []
+                    }
+                });
+                const res = createMockResponse();
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toContain('Expected a lock token');
+            });
+            it('should return 400 when more than one if-header present', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'token1',
+                                    mustMatch: true
+                                }
+                            },
+                            {
+                                token: {
+                                    value: 'token2',
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toContain('Expected a lock token');
+            });
+            it('should return 400 when token extraction fails', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        ifHeaders: [
+                            {
+                                notAToken: true
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                jest.spyOn(_ifheader, 'extractOneToken').mockImplementation(()=>{
+                    throw new Error('No token found');
+                });
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(res.statusCode).toBe(_common.HttpStatus.BAD_REQUEST);
+                expect(res.body).toContain('Unable to extract token');
             });
-            const res = makeRes();
-            filesLockManager.isLockedWithToken.mockResolvedValue(null);
-            jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquetoken:missing');
-            await service.lockRefresh(req, res, req.space.dbFile.path);
-            expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
         });
-        it('returns 403 when owner mismatch', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: undefined,
-                    ifHeaders: [
-                        {
-                            token: {
-                                value: 'opaquetoken:abc',
-                                mustMatch: true
+        describe('Token validation', ()=>{
+            it('should return 412 when token not found or does not match path', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:missing',
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
-            });
-            const res = makeRes();
-            jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquetoken:abc');
-            filesLockManager.isLockedWithToken.mockResolvedValue({
-                owner: {
-                    id: 2
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquelocktoken:missing');
+                filesLockManager.isLockedWithToken.mockResolvedValue(null);
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(filesLockManager.isLockedWithToken).toHaveBeenCalledWith('opaquelocktoken:missing', 'file.txt');
+                expect(res.statusCode).toBe(_common.HttpStatus.PRECONDITION_FAILED);
+            });
+            it('should return 403 when lock owner is different user', async ()=>{
+                const req = createBaseRequest({
+                    user: {
+                        id: 1,
+                        login: 'user1'
+                    },
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquelocktoken:abc');
+                filesLockManager.isLockedWithToken.mockResolvedValue({
+                    owner: {
+                        id: 999,
+                        login: 'other-user'
+                    }
+                });
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
+                expect(res.body).toBe('Lock token does not match owner');
             });
-            await service.lockRefresh(req, res, baseReq().space.dbFile.path);
-            expect(res.statusCode).toBe(_common.HttpStatus.FORBIDDEN);
-            expect(res.body).toBe('Lock token does not match owner');
         });
-        it('returns 200 and XML body on success', async ()=>{
-            const req = baseReq({
-                dav: {
-                    ...baseReq().dav,
-                    body: undefined,
-                    lock: {
-                        ...baseReq().dav.lock,
-                        timeout: 120
+        describe('Successful refresh', ()=>{
+            it('should refresh lock and return 200 with XML body', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        lock: {
+                            ...createBaseRequest().dav.lock,
+                            timeout: 180
+                        },
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
+                            }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const mockLock = {
+                    owner: {
+                        id: 1,
+                        login: 'test-user'
                     },
-                    ifHeaders: [
-                        {
-                            token: {
-                                value: 'opaquetoken:abc',
-                                mustMatch: true
+                    options: {
+                        lockRoot: '/webdav/test/file.txt',
+                        lockToken: 'opaquelocktoken:abc'
+                    }
+                };
+                jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquelocktoken:abc');
+                filesLockManager.isLockedWithToken.mockResolvedValue(mockLock);
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(filesLockManager.refreshLockTimeout).toHaveBeenCalledWith(mockLock, 180);
+                expect(res.statusCode).toBe(_common.HttpStatus.OK);
+                expect(res.contentType).toContain('application/xml');
+                expect(typeof res.body).toBe('string');
+            });
+            it('should use default timeout when not specified', async ()=>{
+                const req = createBaseRequest({
+                    dav: {
+                        ...createBaseRequest().dav,
+                        body: undefined,
+                        lock: {
+                            ...createBaseRequest().dav.lock,
+                            timeout: undefined
+                        },
+                        ifHeaders: [
+                            {
+                                token: {
+                                    value: 'opaquelocktoken:abc',
+                                    mustMatch: true
+                                }
                             }
-                        }
-                    ]
-                }
-            });
-            const res = makeRes();
-            jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquetoken:abc');
-            filesLockManager.isLockedWithToken.mockResolvedValue({
-                owner: {
-                    id: 1
-                },
-                davLock: {
-                    lockroot: '/dav/url'
-                }
+                        ]
+                    }
+                });
+                const res = createMockResponse();
+                const mockLock = {
+                    owner: {
+                        id: 1,
+                        login: 'test-user'
+                    },
+                    options: {
+                        lockRoot: '/webdav/test/file.txt'
+                    }
+                };
+                jest.spyOn(_ifheader, 'extractOneToken').mockReturnValue('opaquelocktoken:abc');
+                filesLockManager.isLockedWithToken.mockResolvedValue(mockLock);
+                await service.lockRefresh(req, res, 'file.txt');
+                expect(filesLockManager.refreshLockTimeout).toHaveBeenCalledWith(mockLock, undefined);
             });
-            await service.lockRefresh(req, res, req.space.dbFile.path);
-            expect(filesLockManager.refreshLockTimeout).toHaveBeenCalled();
-            expect(res.statusCode).toBe(_common.HttpStatus.OK);
-            expect(res.contentType).toContain('application/xml');
-            expect(typeof res.body).toBe('string');
         });
     });
-    describe('handleError integration', ()=>{
-        it('maps LockConflict to 423 Locked via DAV_ERROR_RES', async ()=>{
-            // simulate LockConflict during PUT
-            const { LockConflict } = jest.requireActual('../../files/models/file-lock-error');
-            filesManager.saveStream.mockRejectedValue(new LockConflict({
-                dbFilePath: 'file.txt',
-                davLock: {
-                    lockroot: '/dav/url'
-                }
-            }));
-            const req = baseReq({
-                method: 'PUT'
-            });
-            const res = makeRes();
-            const result = await service.put(req, res);
-            expect(result).toBe(res);
-            expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
-            expect(typeof res.body).toBe('string');
+    describe('handleError (private method)', ()=>{
+        describe('LockConflict errors', ()=>{
+            it('should handle LockConflict with lockRoot', async ()=>{
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'file.txt',
+                    options: {
+                        lockRoot: '/webdav/locked/resource'
+                    }
+                }, 'Lock conflict');
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                const result = service.handleError(req, res, lockError);
+                expect(result).toBe(res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+                expect(res.contentType).toContain('application/xml');
+            });
+            it('should handle LockConflict without lockRoot (fallback to dbFilePath)', async ()=>{
+                const lockError = new _filelockerror.LockConflict({
+                    dbFilePath: 'file.txt'
+                }, 'Lock conflict');
+                const req = createBaseRequest({
+                    method: 'DELETE'
+                });
+                const res = createMockResponse();
+                const result = service.handleError(req, res, lockError);
+                expect(result).toBe(res);
+                expect(res.statusCode).toBe(_common.HttpStatus.LOCKED);
+            });
         });
-        it('maps FileError to its httpCode and message', async ()=>{
-            const { FileError } = jest.requireActual('../../files/models/file-error');
-            filesManager.delete.mockRejectedValue(new FileError(409, 'conflict happened'));
-            const req = baseReq({
-                method: 'DELETE'
-            });
-            const res = makeRes();
-            const result = await service.delete(req, res);
-            expect(result).toBe(res);
-            expect(res.statusCode).toBe(409);
-            expect(res.body).toBe('conflict happened');
+        describe('FileError errors', ()=>{
+            it('should handle FileError and return correct status code', async ()=>{
+                const fileError = new _fileerror.FileError(409, 'Conflict: file already exists');
+                const req = createBaseRequest({
+                    method: 'MKCOL'
+                });
+                const res = createMockResponse();
+                const result = service.handleError(req, res, fileError);
+                expect(result).toBe(res);
+                expect(res.statusCode).toBe(409);
+                expect(res.body).toBe('Conflict: file already exists');
+            });
+            it('should strip additional error information after comma', async ()=>{
+                const fileError = new _fileerror.FileError(404, 'File not found, /real/path/details');
+                const req = createBaseRequest({
+                    method: 'GET'
+                });
+                const res = createMockResponse();
+                const result = service.handleError(req, res, fileError);
+                expect(result).toBe(res);
+                expect(res.statusCode).toBe(404);
+                expect(res.body).toBe('File not found');
+            });
         });
-        it('throws 500 HttpException for unexpected errors', async ()=>{
-            const req = baseReq({
-                method: 'PUT'
+        describe('Unexpected errors', ()=>{
+            it('should throw HttpException for unexpected errors', ()=>{
+                const unexpectedError = new Error('Database connection failed');
+                const req = createBaseRequest({
+                    method: 'PUT'
+                });
+                const res = createMockResponse();
+                expect(()=>{
+                    ;
+                    service.handleError(req, res, unexpectedError);
+                }).toThrow(_common.HttpException);
+            });
+            it('should log error with method and URL', ()=>{
+                const logSpy = jest.spyOn(service['logger'], 'error').mockImplementation(()=>undefined);
+                const req = createBaseRequest({
+                    method: 'PUT',
+                    dav: {
+                        ...createBaseRequest().dav,
+                        url: '/webdav/test.txt'
+                    }
+                });
+                const res = createMockResponse();
+                const error = new Error('Test error');
+                try {
+                    ;
+                    service.handleError(req, res, error);
+                } catch  {
+                // Expected to throw
+                }
+                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('PUT'));
+                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('/webdav/test.txt'));
+            });
+            it('should include destination URL in log when provided', ()=>{
+                const logSpy = jest.spyOn(service['logger'], 'error').mockImplementation(()=>undefined);
+                const req = createBaseRequest({
+                    method: 'COPY'
+                });
+                const res = createMockResponse();
+                const error = new Error('Copy error');
+                try {
+                    ;
+                    service.handleError(req, res, error, '/webdav/destination.txt');
+                } catch  {
+                // Expected to throw
+                }
+                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(' -> /webdav/destination.txt'));
             });
-            const res = makeRes();
-            filesManager.saveStream.mockRejectedValue(new Error('unexpected'));
-            try {
-                await service.put(req, res);
-                // If we reach this line, the test should fail
-                expect(true).toBe(false);
-            } catch (e) {
-                expect(e).toBeInstanceOf(_common.HttpException);
-                expect(e.getStatus()).toBe(_common.HttpStatus.INTERNAL_SERVER_ERROR);
-            }
         });
     });
 });