webdav.client 5.20.5664

package/Tests/Locks/Etag.js

@@ -0,0 +1,277 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Locks.Etag');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Locks.Etag
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Locks.Etag', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Locks.Etag */{
+
+    GetEtag: function (test, sName, fCallback) {
+        var sFolderPath = Helper.GetAbsolutePath('Locks/Etag' + sName);
+        var sFilePath = Helper.GetAbsolutePath('Locks/Etag' + sName + '/etag.txt');
+        var oEtagPropertyName = new ITHit.WebDAV.Client.PropertyName('getetag', ITHit.WebDAV.Client.DavConstants.NamespaceUri);
+
+        var aEtags = [];
+        var methodsCount = 4;
+        var push = function (method, etag) {
+            if (etag === false) {
+                methodsCount--;
+                console.log('Method ' + method + ' not support for get etag.');
+            } else {
+                aEtags.push([method, etag]);
+            }
+
+            if (aEtags.length === methodsCount) {
+                // Check etag equals
+                var sEtag = aEtags[0][1];
+                var bIsEquals = true;
+                for (var i = 0, l = aEtags.length; i < l; i++) {
+                    if (sEtag !== aEtags[i][1]) {
+                        bIsEquals = false;
+                        break;
+                    }
+                }
+
+                if (!bIsEquals) {
+                    for (var i2 = 0, l2 = aEtags.length; i2 < l2; i2++) {
+                        console.log(aEtags[i2][0] + ':', aEtags[i2][1]);
+                    }
+                }
+
+                test.strictEqual(bIsEquals, true, 'Check get tags with different methods');
+
+                fCallback(sEtag);
+            }
+        };
+
+        // GET
+        webDavSession.OpenFileAsync(sFilePath, null, function (oAsyncResult) {
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            var oRequest = oFile.ReadContentAsync(null, null, function () {
+                var etag = oRequest.GetInternalRequests()[0].Response.GetResponseHeader('etag');
+                push('GET', etag !== undefined ? etag : false);
+            });
+        });
+
+        // HEAD
+        webDavSession.OpenFolderAsync(sFolderPath, null, function (oAsyncResult) {
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            var oRequest = oFolder.ItemExistsAsync('etag.txt', function () {
+                var etag = oRequest.GetInternalRequests()[0].Response.GetResponseHeader('etag');
+                push('HEAD', etag !== undefined ? etag : false);
+            });
+        });
+
+        // PROPFIND Depth 0
+        webDavSession.OpenFileAsync(sFilePath, [oEtagPropertyName], function (oAsyncResult) {
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            push('PROPFIND Depth 0', oFile.GetProperty(oEtagPropertyName));
+        });
+
+        // PROPFIND Depth 1
+        webDavSession.OpenFolderAsync(sFolderPath, null, function (oFolderAsyncResult) {
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetChildrenAsync(false, [oEtagPropertyName], function (oAsyncResult) {
+                /** @typedef {ITHit.WebDAV.Client.File[]} aFiles */
+                var aFiles = oAsyncResult.Result;
+
+                push('PROPFIND Depth 1', aFiles[0].GetProperty(oEtagPropertyName));
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Lock file, check etag no change', function (test) {
+    var sName = 'lock';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+        if (oFile.SupportedLocks.length === 0) {
+            return ITHitTests.skip(test, 'Server does not support locks.');
+        }
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+            oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, 'User 1', -1, QUnitRunner.async(function () {
+                ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+
+                    test.strictEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                    webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                        /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                        var oLockedFile = oAsyncResult.Result;
+
+                        test.strictEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that LastModified did not changed');
+                    }));
+                }));
+            }));
+        }));
+    }));
+});
+
+QUnitRunner.test('Update file, check etag change', function (test) {
+    var sName = 'update';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+        if (oFile.SupportedLocks.length === 0) {
+            return ITHitTests.skip(test, 'Server does not support locks.');
+        }
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+
+            oFile.WriteContentAsync('Changes!', null, 'text/plain', QUnitRunner.async(function (oAsyncResult) {
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of write content to file');
+
+                ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+
+                    test.notEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                    webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                        /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                        var oLockedFile = oAsyncResult.Result;
+
+                        test.notEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that etag did not changed');
+                    }));
+                }));
+            }));
+        }));
+    }));
+});
+
+QUnitRunner.test('Lock file, unlock, check etag no change', function (test) {
+    var sName = 'lock';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+        if (oFile.SupportedLocks.length === 0) {
+            return ITHitTests.skip(test, 'Server does not support locks.');
+        }
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+            oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, 'User 1', -1, QUnitRunner.async(function (oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                var oLockInfo = oAsyncResult.Result;
+
+                oFile.UnlockAsync(oLockInfo.LockToken.LockToken, QUnitRunner.async(function () {
+                    ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+
+                        test.strictEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                        webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                            var oLockedFile = oAsyncResult.Result;
+
+                            test.strictEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that LastModified did not changed');
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }));
+});
+
+QUnitRunner.test('Add file custom property, check etag no change', function (test) {
+    var sName = 'add_property';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    var oPropertyName = new ITHit.WebDAV.Client.PropertyName('myname', 'mynamespace');
+    var oProperty = new ITHit.WebDAV.Client.Property(oPropertyName, 'first value');
+
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+
+            oFile.UpdatePropertiesAsync([oProperty], null, null, QUnitRunner.async(function (oAsyncResult) {
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of add property request');
+
+                ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+                    test.strictEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                    webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                        /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                        var oLockedFile = oAsyncResult.Result;
+
+                        test.strictEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that LastModified did not changed');
+                    }));
+                }));
+            }));
+        }));
+    }));
+});
+
+QUnitRunner.test('Update file custom property, check etag no change', function (test) {
+    var sName = 'update_property';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    var oPropertyName = new ITHit.WebDAV.Client.PropertyName('myname', 'mynamespace');
+    var oProperty = new ITHit.WebDAV.Client.Property(oPropertyName, 'Value');
+
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+
+            oFile.UpdatePropertiesAsync([oProperty], null, null, QUnitRunner.async(function (oAsyncResult) {
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of add property request');
+
+                var oUpdatedProperty = new ITHit.WebDAV.Client.Property(oPropertyName, 'Updated value');
+
+                oFile.UpdatePropertiesAsync([oUpdatedProperty], null, null, QUnitRunner.async(function (oAsyncResult) {
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of add property request');
+
+                    ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+                        test.strictEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                        webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                            var oLockedFile = oAsyncResult.Result;
+
+                            test.strictEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that LastModified did not changed');
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }));
+});
+
+
+QUnitRunner.test('Delete file custom property, check etag no change', function (test) {
+    var sName = 'delete_property';
+    var sFilePath = 'Locks/Etag' + sName + '/etag.txt';
+    var oPropertyName = new ITHit.WebDAV.Client.PropertyName('myname', 'mynamespace');
+    var oProperty = new ITHit.WebDAV.Client.Property(oPropertyName, 'Value');
+
+    Helper.Create(sFilePath, QUnitRunner.async(function (oFile) {
+
+        ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sEtag) {
+
+            oFile.UpdatePropertiesAsync([oProperty], null, null, QUnitRunner.async(function (oAsyncResult) {
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of add property request');
+
+                oFile.UpdatePropertiesAsync(null, [oPropertyName], null, QUnitRunner.async(function (oAsyncResult) {
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of add property request');
+
+                    ITHit.WebDAV.Client.Tests.Locks.Etag.GetEtag(test, sName, QUnitRunner.async(function (sNewEtag) {
+                        test.strictEqual(sEtag, sNewEtag, 'Check that etag did not changed');
+
+                        webDavSession.OpenFileAsync(Helper.GetAbsolutePath(sFilePath), null, QUnitRunner.async(function (oAsyncResult) {
+                            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                            var oLockedFile = oAsyncResult.Result;
+
+                            test.strictEqual(String(oFile.LastModified), String(oLockedFile.LastModified), 'Check that LastModified did not changed');
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }));
+});

package/Tests/Locks/GetLocks.js

@@ -0,0 +1,117 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Locks.GetLocks');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Locks.GetLocks
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Locks.GetLocks', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Locks.GetLocks */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetList: function(webDavSession, sFileAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            // Infinite lock
+            oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, "User 1", -1, function(oInfiniteLockAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.LockInfo} oInfiniteLockInfo */
+                var oInfiniteLockInfo = oInfiniteLockAsyncResult.Result;
+
+                // Minute lock
+                oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, "User 2", 60, function(oMinuteLockAsyncResult) {
+
+                    /** @typedef {ITHit.WebDAV.Client.LockInfo} oMinuteLockInfo */
+                    var oMinuteLockInfo = oMinuteLockAsyncResult.Result;
+
+                    // Refresh item from server to read locks
+                    oFile.RefreshAsync(function(oAsyncResult) {
+
+                        for (var i = 0, l = oFile.ActiveLocks.length; i < l; i++) {
+
+                            /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                            var oLockInfo = oFile.ActiveLocks[i];
+                            var sTimeOut = oLockInfo.TimeOut === -1 ? "Infinite" : oLockInfo.TimeOut + ' sec';
+
+                            // Show item locks
+                            console.log([
+                                oLockInfo.Owner,
+                                oLockInfo.LockToken.Href,
+                                oLockInfo.LockToken.LockToken,
+                                oLockInfo.LockScope,
+                                oLockInfo.Deep,
+                                sTimeOut
+                            ].join(' '));
+                        }
+
+                        fCallback(oFile, oInfiniteLockInfo, oMinuteLockInfo);
+                    });
+
+                });
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Lock file, refresh and get it locks list', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Locks/getlockfile.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.Locks.GetLocks.GetList(webDavSession, Helper.GetAbsolutePath('Locks/getlockfile.txt'), function(oFile, oInfiniteLockInfo, oMinuteLockInfo) {
+            QUnit.start();
+
+            if (oFile.SupportedLocks.length === 0) {
+                ITHitTests.skip(test, 'Server does not support locks.');
+                return;
+            }
+
+            var oLocalInfiniteLockInfo = null;
+            var oLocalMinuteLockInfo = null;
+            for (var i = 0, l = oFile.ActiveLocks.length; i < l; i++) {
+                if (oFile.ActiveLocks[i].LockToken.toString() === oInfiniteLockInfo.LockToken.toString()) {
+                    oLocalInfiniteLockInfo = oFile.ActiveLocks[i];
+                }
+                if (oFile.ActiveLocks[i].LockToken.toString() === oMinuteLockInfo.LockToken.toString()) {
+                    oLocalMinuteLockInfo = oFile.ActiveLocks[i];
+                }
+            }
+
+            test.strictEqual(oFile.ActiveLocks.length, 2, 'Check active locks length');
+            test.strictEqual(oLocalInfiniteLockInfo.Owner, 'User 1', 'Infinite lock: check owner');
+            test.strictEqual(oLocalInfiniteLockInfo.LockToken.Href, Helper.GetAbsolutePath('Locks/getlockfile.txt'), 'Infinite lock: check href');
+            test.strictEqual(oLocalInfiniteLockInfo.LockToken.LockToken, oInfiniteLockInfo.LockToken.toString(), 'Infinite lock: check token');
+            test.strictEqual(oLocalInfiniteLockInfo.LockToken.toString(), oInfiniteLockInfo.LockToken.toString(), 'Infinite lock: check token by toString()');
+            test.strictEqual(oLocalMinuteLockInfo.Owner, 'User 2', 'Minute lock: check owner');
+            test.strictEqual(oLocalMinuteLockInfo.LockToken.Href, Helper.GetAbsolutePath('Locks/getlockfile.txt'), 'Minute lock: check href');
+            test.strictEqual(oLocalMinuteLockInfo.LockToken.LockToken, oMinuteLockInfo.LockToken.toString(), 'Minute lock: check token');
+            test.strictEqual(oLocalMinuteLockInfo.LockToken.toString(), oMinuteLockInfo.LockToken.toString(), 'Minute lock: check token by toString()');
+
+            QUnit.stop();
+            oFile.UnlockAsync(oInfiniteLockInfo.LockToken, function(oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of unlock first lock request');
+
+                QUnit.stop();
+                oFile.UnlockAsync(oMinuteLockInfo.LockToken, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of unlock second lock request');
+                });
+            });
+        });
+    });
+});

package/Tests/Locks/Lock.js

@@ -0,0 +1,134 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Locks.Lock');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Locks.Lock
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Locks.Lock', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Locks.Lock */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    SetLock: function(webDavSession, sFileAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            if (oFile.SupportedLocks.length === 0) {
+                console.log('Locks are not supported.');
+                return;
+            }
+
+            oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, 'User 1', -1, function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                var oLockInfo = oAsyncResult.Result;
+
+                if (oAsyncResult.IsSuccess) {
+                    console.log('Locks token is: ' + oLockInfo.LockToken.LockToken);
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    },
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {string} [sLockToken='f36726d1-0671-4f6f-8445-c7d10e42a08e']
+     * @param {function} [fCallback=function() {}]
+     */
+    SetUnLock: function(webDavSession, sFileAbsolutePath, sLockToken, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.UnlockAsync(sLockToken, function(oAsyncResult) {
+
+                if (oAsyncResult.IsSuccess) {
+                    console.log('File is unlocked');
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Lock file and check that it can not be moved', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Locks/MoveDir/',
+        'Locks/lockfile.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Locks/lockfile.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            if (oFile.SupportedLocks.length === 0) {
+                ITHitTests.skip(test, 'Server does not support locks.');
+                return;
+            }
+
+            QUnit.stop();
+            webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('Locks/MoveDir/'), null, function(oAsyncResult) {
+                QUnit.start();
+
+                /** @typedef {ITHit.WebDAV.Client.Folder} oMoveFolder */
+                var oMoveFolder = oAsyncResult.Result;
+
+                QUnit.stop();
+                ITHit.WebDAV.Client.Tests.Locks.Lock.SetLock(webDavSession, Helper.GetAbsolutePath('Locks/lockfile.txt'), function(oAsyncResult) {
+                    QUnit.start();
+
+                    /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                    var oLockInfo = oAsyncResult.Result;
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of set lock request');
+                    test.strictEqual(oLockInfo instanceof ITHit.WebDAV.Client.LockInfo, true, 'Check result is instance of LockInfo');
+                    test.strictEqual(oLockInfo.Deep, false, 'Check lock info deep is false');
+                    test.strictEqual(oLockInfo.LockScope, ITHit.WebDAV.Client.LockScope.Shared, 'Check lock is shared');
+                    test.strictEqual(oLockInfo.LockToken.Href, Helper.GetAbsolutePath('Locks/lockfile.txt'), 'Check lock href');
+
+                    // Try move
+                    QUnit.stop();
+                    oFile.MoveToAsync(oMoveFolder, oFile.DisplayName, false, null, function(oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.LockedException, true, 'Check error is LockedException on try move file without lock token');
+
+                        // Try move with lock
+                        QUnit.stop();
+                        oFile.MoveToAsync(oMoveFolder, oFile.DisplayName, false, [oLockInfo], function(oAsyncResult) {
+                            QUnit.start();
+
+                            // Try move
+                            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of move file request with lock token');
+
+                            QUnit.stop();
+                            ITHit.WebDAV.Client.Tests.Locks.Lock.SetUnLock(webDavSession, Helper.GetAbsolutePath('Locks/MoveDir/lockfile.txt'), oLockInfo.LockToken.LockToken, function(oAsyncResult) {
+                                QUnit.start();
+
+                                test.strictEqual(oAsyncResult.IsSuccess, false, 'Check success of unlock request');
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/Locks/RefreshLock.js

@@ -0,0 +1,94 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Locks.RefreshLock');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Locks.RefreshLock
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Locks.RefreshLock', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Locks.RefreshLock */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    RefreshLock: function(webDavSession, sFileAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.LockAsync(ITHit.WebDAV.Client.LockScope.Shared, false, 'User 1', 60, function(oLockAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                var oLockInfo = oLockAsyncResult.Result;
+
+                if (oLockAsyncResult.IsSuccess) {
+                    console.log('Lock timeout is: ' + oLockInfo.TimeOut);
+                }
+
+                oFile.RefreshLockAsync(oLockInfo.LockToken.toString(), 300, function(oRefreshAsyncResult) {
+
+                    /** @typedef {ITHit.WebDAV.Client.LockInfo} oLockInfo */
+                    var oRefreshedLockInfo = oRefreshAsyncResult.Result;
+
+                    if (oRefreshAsyncResult.IsSuccess) {
+                        console.log('Lock timeout is: ' + oRefreshedLockInfo.TimeOut);
+                    }
+
+                    fCallback(oLockAsyncResult, oRefreshAsyncResult);
+                });
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Refresh lock on a file', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Locks/refreshlockfile.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Locks/refreshlockfile.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            if (oFile.SupportedLocks.length === 0) {
+                ITHitTests.skip(test, 'Server does not support locks.');
+                return;
+            }
+
+            QUnit.stop();
+            ITHit.WebDAV.Client.Tests.Locks.RefreshLock.RefreshLock(webDavSession, Helper.GetAbsolutePath('Locks/refreshlockfile.txt'), function(oLockAsyncResult, oRefreshAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oLockAsyncResult.IsSuccess, true, 'Check success of lock request');
+                test.strictEqual(oLockAsyncResult.Result.TimeOut, 60, 'Check previous lock timeout');
+                test.strictEqual(oRefreshAsyncResult.IsSuccess, true, 'Check success of refresh lock request');
+                test.strictEqual(oRefreshAsyncResult.Result.TimeOut, 300, 'Check current lock timeout');
+
+                QUnit.stop();
+                webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Locks/refreshlockfile.txt'), null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                    var oFile = oAsyncResult.Result;
+
+                    QUnit.stop();
+                    oFile.UnlockAsync(oRefreshAsyncResult.Result.LockToken.toString(), function(oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of unlock request');
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/Upload/CancelUpload.js

@@ -0,0 +1,34 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Upload.CancelUpload');
+
+QUnitRunner.test('Cancel upload on created file', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Upload/cancel_file2.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Upload/cancel_file2.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFile = oAsyncResult.Result;
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open item request');
+            test.strictEqual(oFile instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+            test.strictEqual(oFile.ResumableUpload instanceof ITHit.WebDAV.Client.ResumableUpload, true, 'Check file have link to ResumableUpload instance');
+
+            // Async variant
+            QUnit.stop();
+            oFile.ResumableUpload.CancelUploadAsync(null, function(oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of cancel upload request');
+            });
+        });
+    });
+});